Delete pages

pages/Module_01.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_01"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_02.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_02"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_03.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_03"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_04.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_04"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_05.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_05"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_06.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_06"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_07.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_07"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_08.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_08"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_09.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_09"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_10.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_10"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Module_11.py

@@ -1,26 +0,0 @@
-CURRENT_MODULE = "Module_11"
-  
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")   
-
-
-
-
-
-
-
-
-
-

pages/Overview.py

@@ -1,27 +0,0 @@
-CURRENT_MODULE = "Overview"
-
-# Imports
-
-import streamlit as st
-import streamlit.components.v1 as components
-from   pages  import load_pages
-
-if "logged_in" not in st.session_state:
-   pass
-else:
-   load_pages.load_page(CURRENT_MODULE)
-   
-if __name__ == "__main__":
-   load_pages.test_load()
-   print("<<< Module [", CURRENT_MODULE, "] Compile Successful >>>")      
-   
-
-
-
-
-
-
-
-
-
-

pages/__init__.py

@@ -1,14 +0,0 @@
-
-if __name__ == "__main__":
-    print("<<< __init__ Compile Successful >>>")    
-   
-
-
-
-
-
-
-
-
-
-

pages/assets/ascend.mp4

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:47da52ba29d9ec1dd51515d57a9e44077fdb555f381c7489d0579a5986d072d1
-size 9958440

pages/assets/juicy_fruit.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d6b27c967e75704148a1ebc0df70dd4fb13d5571ce2af02e87334139acb3ef3a
-size 735859

pages/assets/overview.txt

@@ -1,56 +0,0 @@
-# Welcome to ASCEND: Your Comprehensive AI Learning Solution
-
-**ASCEND** is an innovative, highly integrated learning platform designed to empower users in mastering Artificial Intelligence (AI). Combining theoretical foundations with practical, interactive experiences, ASCEND provides a structured, engaging, and robust learning environment tailored for beginners and advanced AI enthusiasts alike.
-
-### Key Features of ASCEND:
-- **Real-World Use Cases:** Work on practical projects and case studies to apply your AI knowledge on realistic scenarios and problems.
-- **Interactive Learning Modules:** Learn essential AI concepts such as machine learning, deep learning, natural language processing, and computer vision.
-- **Sandbox Environments:** Safely experiment with algorithms, data sets, and AI models within virtual environments.
-- **Comprehensive AI Toolkit:** Access a rich repository of AI tools and resources integrated within the learning environment.
-- **Community-driven Support:** Engage with a vibrant community of learners, mentors, and AI experts to enhance your learning journey.
-
----
-
-## Sample AI Questions to try in Our Chat
-
-Copy and paste these questions to deepen your understanding of AI.
-
-```markdown
-Can you explain the key differences between supervised, unsupervised, and reinforcement learning?
-```
-
-```markdown
-What are some common techniques used to prevent overfitting in machine learning models?
-```
-
-```markdown
-How do neural networks work, and can you provide a simple, step-by-step example?
-```
-
-```markdown
-What's the difference between convolutional neural networks (CNNs) and recurrent neural networks (RNNs)?
-```
-
-```markdown
-How does Natural Language Processing (NLP) simplify the interaction between humans and machines?
-```
-
-```markdown
-Can you guide me through the process of training and validating a machine learning model step by step?
-```
-
-```markdown
-What are large language models, and how do they work to generate text?
-```
-
-```markdown
-Could you provide an overview of ethical considerations when developing and deploying AI systems?
-```
-
-```markdown
-What tools and software libraries would you recommend for beginning AI practitioners?
-```
-
-```markdown
-How does computer vision enable machines to interpret visual data, and can you give an example application?
-```

pages/assets/profile.txt

@@ -1,17 +0,0 @@
-# 🚀 ASCEND Program: Student Profile
-
-- **Student Name:** Charlie B
-- **Department:** BMO Wealth
-- **Expertise:** Intermediate
-
-## 🎯 Interests:
-- Data science and analytics
-- Predictive models
-- Capital market applications
-
-## 🎯 Goals for Next Review:
-- Complete topics in **Supervised Learning**.
-- Begin study on Advanced Optimization Methods.
-- Initiate **Computer Vision** topics.
-
-**🚀 Keep up the excellent work 🚀**

pages/assets/progress.txt

@@ -1,116 +0,0 @@
-# 🚀 ASCEND Program: AI Learning Progress Report
-
-- **Student Name:** Charlie B
-- **Enrollment Date:** Sept 15, 2025
-- **Report Date:** Nov 2, 2025
-
----
-
-# 📚 Progress Overview
-Completed topics are marked with a checkmark (✔️), 
-while incomplete or pending topics remain unchecked.
-
-## 📈 Overall Progress Summary
-
-| Curriculum Area              | Completion (%) |
-|------------------------------|----------------|
-| Statistics & Probability     | 67%            |
-| Linear Algebra               | 80%            |
-| Calculus & Optimization      | 83%            |
-| Python for ML                | 100%           |
-| Supervised Learning          | 60%            |
-| Unsupervised Learning        | 75%            |
-| Deep Learning                | 40%            |
-| NLP                          | 25%            |
-| Computer Vision              | 0%             |
-
----
-
-## ✅ Python Programming
-| Subtopic                           | Status  |
-|------------------------------------|---------|
-| Python Fundamentals               | ✔️      |
-| NumPy & Arrays                    | ✔️      |
-| Pandas & Data Manipulation        | ✔️      |
-| Data Visualization with Matplotlib| ✔️      |
-
----
-
-## 🔄 Supervised Learning
-| Subtopic                        | Status  |
-|---------------------------------|---------|
-| Regression Analysis             | ✔️      |
-| Classification Algorithms       | ✔️      |
-| Decision Trees                  | ✔️      |
-| Ensemble Methods (Random Forest)|         |
-
----
-
-## 🔄 Unsupervised Learning
-| Subtopic                      | Status  |
-|-------------------------------|---------|
-| Clustering Methods (K-means)  | ✔️      |
-| Dimensionality Reduction      | ✔️      |
-| Principal Component Analysis (PCA)| ✔️      |
-| t-SNE and Embeddings          |         |
-
----
-
-## 🔄 Deep Learning
-| Subtopic                               | Status  |
-|----------------------------------------|---------|
-| Neural Networks Basics                 | ✔️      |
-| Neural Network Training                | ✔️      |
-| Convolutional Neural Networks (CNNs)   |         |
-| Recurrent Neural Networks (RNNs & LSTM)|         |
-| Introduction to Transformers           |         |
-
----
-
-## ⏩ Natural Language Processing (NLP)
-| Subtopic                                | Status  |
-|-----------------------------------------|---------|
-| Tokenization & Text Preprocessing       | ✔️      |
-| Sentiment Analysis                      |         |
-| Text Classification Techniques          |         |
-| Introduction to Large Language Models   |         |
-
----
-
-## ✅ Statistics and Probability
-| Subtopic                               | Status  |
-|----------------------------------------|---------|
-| Measures of Central Tendency           | ✔️      |
-| Variance and Standard Deviation        | ✔️      |
-| Probability Distributions              | ✔️      |
-| Central Limit Theorem & Applications   | ✔️      |
-| Hypothesis Testing                     |         |
-| Bayesian Statistics                    |         |
-
----
-
-## ✅ Linear Algebra & Matrix Math
-| Subtopic                    | Status  |
-|-----------------------------|---------|
-| Matrix Operations           | ✔️      |
-| Eigenvalues and Eigenvectors| ✔️      |
-| Matrix Factorization        |         |
-| Vector Spaces               | ✔️      |
-| Linear Transformations      | ✔️      |
-
----
-
-## 🔄 Calculus & Optimization
-| Subtopic                      | Status  |
-|-------------------------------|---------|
-| Differential Calculus Basics  | ✔️      |
-| Partial Derivatives           | ✔️      |
-| Gradients and Directional Derivatives | ✔️      |
-| Optimization Techniques       | ✔️      |
-| Gradient Descent Overview     | ✔️      |
-| Advanced Optimization Methods (Momentum, RMSProp, Adam)|         |
-
-
----
-
-**Keep up the excellent work, you're well on your way to AI mastery! 🚀**

pages/assets/sample_formula_text.txt

@@ -1,60 +0,0 @@
-The normal distribution, often called the Gaussian distribution, is among the most important probability distributions in statistics. Here's the formula for its probability density function and its moment-generating function:
-
-1. **Normal Distribution Probability Density Function (PDF):**
-
-The formula for the PDF of a normal distribution with mean \( \mu \) and standard deviation \( \sigma \) is:
-
-\[
-f(x) = \frac{1}{\sigma \sqrt{2\pi}} e^{-\frac{(x - \mu)^2}{2\sigma^2}}
-\]
-
-   - \( x \) is a value for which we're finding the probability density.
-   - \( \mu \) is the mean of the distribution.
-   - \( \sigma \) is the standard deviation.
-   - \( \pi \) is a constant approximately equal to 3.14159.
-   - \( e \) is Euler's number, approximately equal to 2.71828.
-
-   This formula describes the familiar bell-shaped curve that characterizes the normal distribution, showing how probabilities are distributed over the range of possible values.
-
-2. **Moment Generating Function (MGF) for a Normal Distribution:**
-
-The MGF of a normal distribution can be derived and is given by:
-
-\[
-M_X(t) = e^{\mu t + \frac{1}{2} \sigma^2 t^2}
-\]
-
-   - \( M_X(t) \) is the moment-generating function of the random variable \( X \) with mean \( \mu \) and standard deviation \( \sigma \).
-   - \( t \) is the point at which the MGF is evaluated.
-
-The MGF for the normal distribution uniquely characterizes the distribution. It's especially useful in deriving properties such as the mean and variance, and it simplifies working with sums of independent normal random variables, thanks to the aforementioned product property of MGFs.The normal distribution, often called the Gaussian distribution, is among the most important probability distributions in statistics. Here's the formula for its probability density function and its moment-generating function:
-
-1. **Normal Distribution Probability Density Function (PDF):**
-
-   The formula for the PDF of a normal distribution with mean \( \mu \) and standard deviation \( \sigma \) is:
-
-   \[
-   f(x) = \frac{1}{\sigma \sqrt{2\pi}} e^{-\frac{(x - \mu)^2}{2\sigma^2}}
-   \]
-
-   - \( x \) is a value for which we're finding the probability density.
-   - \( \mu \) is the mean of the distribution.
-   - \( \sigma \) is the standard deviation.
-   - \( \pi \) is a constant approximately equal to 3.14159.
-   - \( e \) is Euler's number, approximately equal to 2.71828.
-
-   This formula describes the familiar bell-shaped curve that characterizes the normal distribution, showing how probabilities are distributed over the range of possible values.
-
-2. **Moment Generating Function (MGF) for a Normal Distribution:**
-
-   The MGF of a normal distribution can be derived and is given by:
-
-   \[
-   M_X(t) = e^{\mu t + \frac{1}{2} \sigma^2 t^2}
-   \]
-
-   - \( M_X(t) \) is the moment-generating function of the random variable \( X \) with mean \( \mu \) and standard deviation \( \sigma \).
-   - \( t \) is the point at which the MGF is evaluated.
-
-The MGF for the normal distribution uniquely characterizes the distribution. It's especially useful in deriving properties such as the mean and variance, and it simplifies working with sums of independent normal random variables, thanks to the aforementioned product property of MGFs.
-

pages/assets/sample_formula_text_01.txt

@@ -1,42 +0,0 @@
-sample_formula_text
-
-The equation for linear regression in matrix form is expressed as:
-
-\[
-\mathbf{y} = \mathbf{X}\mathbf{\beta} + \mathbf{\epsilon}
-\]
-
-Here's what each component represents:
-- \(\mathbf{y}\) is an \(n \times 1\) vector of the response variables (dependent variable) for \(n\) observations.
-- \(\mathbf{X}\) is an \(n \times (p+1)\) matrix of the predictors (independent variables), where \(p\) is the number of predictors. The first column of \(\mathbf{X}\) usually consists of ones to account for the intercept term.
-- \(\mathbf{\beta}\) is a \((p+1) \times 1\) vector of the coefficients, including the intercept and the slopes of the predictors.
-- \(\mathbf{\epsilon}\) is an \(n \times 1\) vector of the error terms.
-
-The estimated coefficients \(\mathbf{\hat{\beta}}\) are usually calculated using the Ordinary Least Squares (OLS) method, which minimizes the sum of the squared differences between the observed responses \(\mathbf{y}\) and the predicted responses \(\mathbf{X}\mathbf{\beta}\). The formula for the OLS estimate of \(\mathbf{\beta}\) is:
-
-\[
-\mathbf{\hat{\beta}} = (\mathbf{X}^T \mathbf{X})^{-1} \mathbf{X}^T \mathbf{y}
-\]
-
-This equation allows for the estimation of the beta coefficients that best fit the data according to the least squares criterion.
-
-
-This equation mixes text with a formula
-
-\[ 
-\text{Let } x = \var{number of cats} \text{, and also }  \var{Overlap Area} = \frac{\Area(\var{Detection} \cap \var{Ground Truth})} {\Area(\var{Detection} \cup \var{Ground Truth})}
-\]
-
-The formula for the normal distribution, also known as the Gaussian distribution, is given by the probability density function (PDF):
-
-\[ f(x \mid \mu, \sigma) = \frac{1}{\sigma \sqrt{2\pi}} e^{-\frac{1}{2} \left( \frac{x - \mu}{\sigma} \right)^2} \]
-
-where:
-- \( \mu \) is the mean,
-- \( \sigma \) is the standard deviation,
-- \( x \) is the variable,
-- \( e \) is the base of the natural logarithm (approximately equal to 2.71828).
-
-In Python, you can work with the normal distribution using libraries like NumPy and SciPy. Here are a few examples of how one might use the normal distribution in Python:
-
-

pages/load_pages.py

@@ -1,212 +0,0 @@
-
-# Imports
-
-import os, time, re, sys
-import numpy as np
-from   openai import OpenAI
-
-import streamlit as st
-import streamlit.components.v1 as components
-
-# --------------------------------------------------------------------------
-# Symbolic Lookup Table - Greek (lower and upper, math and equality signs)
-# --------------------------------------------------------------------------
-
-SYMBOLS: dict[str, str] = {
-    r"\alpha": "α",  r"\beta": "β",   r"\gamma": "γ",   r"\delta": "δ",r"\epsilon": "ε",r"\zeta": "ζ",   r"\eta": "η",     r"\theta": "θ",  r"\iota": "ι",   r"\kappa": "κ",  r"\lambda": "λ",  r"\mu": "μ", r"\nu": "ν",     r"\xi": "ξ",     r"\omicron": "ο", r"\pi": "π",  r"\rho": "ρ",    r"\sigma": "σ",  r"\tau": "τ",     r"\upsilon": "υ", r"\phi": "φ",    r"\chi": "χ",    r"\psi": "ψ",     r"\omega": "ω",
-    r"\Alpha": "Α",  r"\Beta": "Β",   r"\Gamma": "Γ",   r"\Delta": "Δ", r"\Epsilon": "Ε",r"\Zeta": "Ζ",   r"\Eta": "Η",     r"\Theta": "Θ",  r"\Iota": "Ι",   r"\Kappa": "Κ",  r"\Lambda": "Λ",  r"\Mu": "Μ", r"\Nu": "Ν",     r"\Xi": "Ξ",     r"\Omicron": "Ο", r"\Pi": "Π", r"\Rho": "Ρ",    r"\Sigma": "Σ",  r"\Tau": "Τ",     r"\Upsilon": "Υ",     r"\Phi": "Φ",    r"\Chi": "Χ",    r"\Psi": "Ψ",     r"\Omega": "Ω",
-    r"\pm": "±",      r"\times": "×",   r"\div": "÷",        r"\cdot": "·",     r"\sqrt": "√",    r"\sum": "∑",     r"\prod": "∏",       r"\int": "∫", r"\infty": "∞",   r"\partial": "∂", r"\nabla": "∇",     r"\le": "≤",      r"\ge": "≥",      r"\neq": "≠",        r"\approx": "≈",
-    r"\and": "∧",     r"\or": "∨",      r"\neg": "¬",     r"\in": "∈",      r"\notin": "∉",  r"\subset": "⊂",  r"\subseteq": "⊆",r"\supset": "⊃",     r"\supseteq": "⊇",     r"\cup": "∪",     r"\cap": "∩",     r"\angle": "∠",   r"\triangle": "△",
-    r"\therefore": "∴", r"\because": "∵",     r"\propto": "∝",  r"\parallel": "∥",r"\perp": "⊥", r"\degree": "°",  r"\bullet": "•",     r"\rightarrow": "→", r"\leftarrow": "←", r"\uparrow": "↑",
-    r"\downarrow": "↓", r"\leftrightarrow": "↔",     r"\ell": "ℓ",     r"\Re": "ℜ",      r"\Im": "ℑ",     r"\aleph": "ℵ",   r"\wp": "℘"
-}
-
-# =====================================================
-# Functions - to convert symbol tags to symbols
-# =====================================================
-
-FORMULA_REGEX  = re.compile(r'\\[A-Za-z]+')
-BOLD_TXT_REGEX = re.compile(r'\\[A-Za-z]+{([^{}]*)}')
-
-def test_load():
-   print("load_pages - testing external call")
-
-def latex_to_unicode(text: str, table: dict[str, str] = SYMBOLS) -> str:
-   return FORMULA_REGEX.sub(lambda m: table.get(m.group(0), m.group(0)), text)
-
-def latex_bold_to_markdown(text: str) -> str:
-    return BOLD_TXT_REGEX.sub(r'**\1**', text)
-
-def format_text(input_text):
-
-   input_text = input_text.replace("\\[\n",'st.latex("')
-   input_text = input_text.replace("\\[",'st.latex("')
-   input_text = input_text.replace("\n\\]\n",'")\n')
-   input_text = input_text.replace("\\]\n",'")\n')
-
-   # print(input_text)
-
-   for line in input_text.split("\n"):
-      line = line.strip()
-      if line[:len("st.latex(")]=="st.latex(":
-         if line[-2:]=='")': 
-            st.latex(line[len("st.latex(")+1:-2])    # closed expression
-         else:
-            st.latex(line[len("st.latex(")+1:])      # open expression
-      elif line[:2]=='")':                           # closed expression notation - ignore 
-         pass
-      else:
-         line_unicode = latex_to_unicode(line)
-         line_bold    = latex_bold_to_markdown(line_unicode)
-         st.markdown(line_bold)
-
-def chat_response(prompt):
-   pass
-
-##if prompt := st.chat_input("I would like to learn about ..."):
-##    
-##    st.session_state.messages.append({"role": "user", "content": prompt})
-##
-##    with st.chat_message("user"):
-##        st.markdown(prompt)
-##
-##    with st.chat_message("assistant"):
-##
-##        full_text = []
-##
-##        client = st.session_state["openai_client"]
-##
-##        stream = client.chat.completions.create(
-##            model=st.session_state["openai_model"],
-##            messages=[
-##                {"role": m["role"], "content": m["content"]}
-##                for m in st.session_state.messages
-##            ],
-##            stream=True,
-##        )
-##
-##        for chunk in stream:                                 # chunk is a ChatCompletionChunk
-##           delta = chunk.choices[0].delta                    # “what changed since the prev. chunk”
-##           if delta.content:                                 # sometimes None (e.g. first chunk)
-##              print(delta.content, end="", flush=True)       # live printing
-##              full_text.append(delta.content)                # keep it if you need it
-##              response = "".join(full_text)                  # the entire response as one string
-##
-##        print(response)
-##        format_text(response)
-##
-##        # response = st.write_stream(stream)
-##        
-##        st.session_state.messages.append({"role": "assistant", "content": response})
-
-
-def load_content(module):
-
-   tab_list         = ["📈 Slides", "🗃 Overview","🖥 Coding"]
-   tab0, tab1, tab2 = st.tabs(tab_list)
-
-   with tab0:
-       st.header(tab_list[0])
-       st.image(os.path.join(st.session_state["start_dir"],"pages","modules",module,"Overview.jpg"))
-
-   with tab1:
-       st.header(tab_list[1])
-       overview_str = open(os.path.join(st.session_state["start_dir"],"pages","modules",module,"Overview.txt"), "r", encoding="UTF-8").read()
-       st.markdown(overview_str)
-
-   with tab2:
-       st.header(tab_list[2])
-       st.link_button("Go to Lab", r"https://colab.research.google.com/#scrollTo=GDDWVkmPoN7M&fileId=https%3A//huggingface.co/spaces/mswhite/Project_ASCEND/blob/main/Lorenz.ipynb")  # iframe did not work
-
-   return
-
-def load_page(module):
-
-   # =================================================
-   # Top of Page / Sidebar Configuration
-   # =================================================
-
-   st.header("🚀 Project ASCEND 🚀")   
-
-   # st.title() | st.header() | st.subheader() | st.logo() 
-   # st.subheader("AI Supplemented Cognitive Enrichment and Development\n🤖 Ask the ChatBot 🤖")
-
-   # =================================================
-   # Sidebar
-   # =================================================
-
-   with st.sidebar:
-
-      with st.expander("Lessons"):
-
-         st.page_link("pages/Overview.py",label="Will They Buy It - Project Overview", icon="🛍")
-         st.page_link("pages/Module_01.py",label="Introduction to Machine Learning and E-Commerce Context", icon="🛒")
-         st.page_link("pages/Module_02.py",label="Basics of Python Programming", icon="💻")
-         st.page_link("pages/Module_03.py",label="Understanding the Data", icon="🔎")
-         st.page_link("pages/Module_04.py",label="Data Preprocessing & Feature Engineering", icon="🛠")
-         st.page_link("pages/Module_05.py",label="Introduction to Classification and XGBoost", icon="🤖")
-         st.page_link("pages/Module_06.py",label="Building the Predictive Model", icon="📈")
-         st.page_link("pages/Module_07.py",label="Feature Importance and Model Interpretation", icon="💡")
-         st.page_link("pages/Module_08.py",label="Dimensionality Reduction and Feature Selection", icon="🪄")
-         st.page_link("pages/Module_09.py",label="Clustering and User Segmentation", icon="👪")
-         st.page_link("pages/Module_10.py",label="Model Improvement and Ethical Considerations", icon="⚖️")
-         st.page_link("pages/Module_11.py",label="Real-World Deployment and Use Cases", icon="🌐")     
-
-      with st.expander("Your Profile", expanded=False, icon=":material/settings_accessibility:"):       
-         profile_str = open(os.path.join(st.session_state["start_dir"],"pages","assets","profile.txt"), "r", encoding="UTF-8").read()
-         st.markdown(profile_str)
-           
-      with st.expander("Your Progress",expanded=False, icon=":material/preliminary:"):
-         progress_str = open(os.path.join(st.session_state["start_dir"],"pages","assets","progress.txt"), "r", encoding="UTF-8").read()
-         st.markdown(progress_str)
-
-      with st.expander("Sample Math Equations", expanded=False, icon=":material/calculate:"):
-         overview_str = open(os.path.join(st.session_state["start_dir"],"pages","assets","sample_formula_text.txt"), "r", encoding="UTF-8").read()
-         #st.markdown(overview_str)
-         format_text(overview_str)
-
-      with st.expander("Level of Expertise", expanded=False, icon=":material/signal_cellular_alt:"):
-         st.slider("Level of Expertise", 0, 1000, 450, key="slide")
-         st.radio("Your thoughts", ["I agree", "I disagree"], key="radio")
-         st.text_input("Thoughts", placeholder="Add your thoughts", label_visibility="collapsed")
-         st.button("Submit")
-
-      with st.expander("Logout", expanded=False, icon=":material/logout:"):    
-         if st.button("Logout"):
-            del st.session_state["logged_in"]
-            st.rerun()
-
-   # smart_toy (robot) 
-
-
-   # END Sidebar            
-
-   # =================================================
-   # Main Screen Content - e.g. Tabs
-   # =================================================
-
-   if "logged_in" not in st.session_state:                         # User has logged out
-      st.title("🚀 Project ASCEND 🚀")
-      st.image(os.path.join(st.session_state["start_dir"],"pages","assets","logo.jpg"), width=450)
-      st.write("You have left Project Ascend ... Thank You.")
-
-   else:
-      load_content(module)
-
-
-# =================================================
-# Standalone Code if run as Main
-# =================================================   
-
-if __name__ == "__main__":
-   print("<<< Load Pages - Compile Successful >>>")
-
-   
-
-
-
-
-
-
-
-

pages/modules/Module_01/Module_01.ipynb

@@ -1,90 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "46688de2",
-   "metadata": {},
-   "source": [
-    "# Module 1: Introduction to Machine Learning and E-Commerce Context\n",
-    "\n",
-    "## Lesson 1.1: What is Machine Learning?\n",
-    "\n",
-    "- **Machine Learning (ML)** is a technique that enables computers to learn patterns from data and make predictions or decisions without being explicitly programmed.\n",
-    "- Types of ML:\n",
-    "  - *Supervised Learning*: Learn from labeled data (e.g. classification, regression).\n",
-    "  - *Unsupervised Learning*: Find patterns without labels (e.g. clustering).\n",
-    "  - *Reinforcement Learning*: Learn by trial and error with rewards.\n",
-    "- Real-world examples:\n",
-    "  - Email spam detection\n",
-    "  - Product recommendations\n",
-    "  - Image recognition"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fa78899d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Pseudo-code example: Simple spam detection\n",
-    "\n",
-    "def train_supervised_model(features, labels):\n",
-    "    # Imagine this trains a model\n",
-    "    return 'trained_model'\n",
-    "\n",
-    "# Dummy data (for explanation only)\n",
-    "features = ['email features']\n",
-    "labels = ['spam', 'not spam']\n",
-    "model = train_supervised_model(features, labels)\n",
-    "\n",
-    "new_email = 'Some new email data'\n",
-    "prediction = 'spam'  # Dummy prediction\n",
-    "\n",
-    "if prediction == 'spam':\n",
-    "    print(\"This email is spam\")\n",
-    "else:\n",
-    "    print(\"This email is not spam\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "13f0169f",
-   "metadata": {},
-   "source": [
-    "## Lesson 1.2: Business Problem — Predicting Purchase from Browsing Behavior\n",
-    "\n",
-    "- E-commerce sites want to understand if users will buy now, later, or possibly never.\n",
-    "- Benefits include: personalized marketing, better inventory control, targeted ads.\n",
-    "- Typical purchase intent labels:\n",
-    "  - **Purchase Now**: User makes a purchase during session.\n",
-    "  - **Purchase Later**: User did not buy now but buys within a time window later.\n",
-    "  - **No Purchase**: User only browses with no buying intent detected.\n",
-    "\n",
-    "### Exercise:\n",
-    "- Think of 3 behaviors on a website that might indicate buying intent."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_01/Overview.txt

@@ -1,13 +0,0 @@
-Module 1: Introduction to Machine Learning and E-Commerce Context
-
-Lesson 1.1: What is Machine Learning?
-
-o	Brief overview of ML concepts
-o	Types of ML (supervised, unsupervised, reinforcement)
-o	Real-world ML applications
-
-Lesson 1.2: Business Problem — Predicting Purchase from Browsing Behavior
-
-o	Understanding e-commerce purchase funnels
-o	Why predict purchase intent?
-o	Types of user outcomes: purchase now, purchase later, no intent to purchase

pages/modules/Module_02/Module_02.ipynb

@@ -1,158 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "fde9e65f",
-   "metadata": {},
-   "source": [
-    "# Module 2: Basics of Python Programming\n",
-    "\n",
-    "## Lesson 2.1: Python Essentials for ML\n",
-    "\n",
-    "- Variables, data types, basic functions\n",
-    "- Control flow: loops and conditionals\n",
-    "- Using Jupyter Notebook for interactive coding"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17367a18",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example: Variables and types\n",
-    "user_name = \"Alice\"\n",
-    "pages_visited = 5\n",
-    "average_time_on_page = 12.5  # minutes\n",
-    "is_returning_visitor = True\n",
-    "\n",
-    "print(\"User:\", user_name)\n",
-    "print(\"Pages Visited:\", pages_visited)\n",
-    "print(\"Avg Time per Page:\", average_time_on_page)\n",
-    "print(\"Returning Visitor?\", is_returning_visitor)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e0bda962",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example: Conditional statements\n",
-    "if pages_visited > 3:\n",
-    "    print(user_name + \" is engaged with the website.\")\n",
-    "else:\n",
-    "    print(user_name + \" is casually browsing.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ebf9beb3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example: Loop to print page numbers visited\n",
-    "for page in range(1, pages_visited + 1):\n",
-    "    print(f\"Visited page {page}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "da881d36",
-   "metadata": {},
-   "source": [
-    "## Lesson 2.2: Libraries for Data Science\n",
-    "\n",
-    "Introduction to essential Python libraries:\n",
-    "- **NumPy**: numerical computing\n",
-    "- **Pandas**: data manipulation and analysis\n",
-    "- **Matplotlib** and **Seaborn**: data visualization"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2b8d230c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "\n",
-    "# Create a simple sample dataset\n",
-    "data = {\n",
-    "    'session_id': [1, 2, 3, 4, 5],\n",
-    "    'pages_visited': [5, 3, 8, 2, 7],\n",
-    "    'session_duration': [45, 25, 80, 15, 60]  # in minutes\n",
-    "}\n",
-    "\n",
-    "df = pd.DataFrame(data)\n",
-    "print(df.head())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "68d69205",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Plotting number of pages visited per session\n",
-    "plt.figure(figsize=(8, 5))\n",
-    "sns.barplot(x=df['session_id'], y=df['pages_visited'], palette='viridis')\n",
-    "plt.title('Pages Visited per Session')\n",
-    "plt.xlabel('Session ID')\n",
-    "plt.ylabel('Pages Visited')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9bb97233",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Write a function `engagement_label(pages)` that returns \"High engagement\" if pages > 4, else \"Low engagement\".\n",
-    "2. Load a CSV file called `sample_browsing_data.csv` (you can create one or I can provide sample data later) and print basic statistics.\n",
-    "3. Plot a histogram of session durations from the loaded data."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "079950e5",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- What are the differences between Python data types?\n",
-    "- When do we use for loops versus while loops?\n",
-    "- How does Jupyter Notebook help with data science?\n",
-    "- Why do we import libraries and what are they used for?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_02/Overview.txt

@@ -1,12 +0,0 @@
-Module 2: Basics of Python Programming
-
-Lesson 2.1: Python Essentials for ML
-
-o	Data types, variables, functions
-o	Control structures (loops, conditionals)
-o	Introduction to Jupyter Notebooks
-
-Lesson 2.2: Libraries for Data Science
-
-o	NumPy and Pandas for data manipulation
-o	Matplotlib and Seaborn for data visualization

pages/modules/Module_03/Module_03.ipynb

@@ -1,122 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 3: Understanding the Data\n",
-    "\n",
-    "## Lesson 3.1: Exploring Web Browsing Behavior Data\n",
-    "\n",
-    "- Discuss typical features in browsing datasets:\n",
-    "  - session_duration (seconds or minutes)\n",
-    "  - pages_visited\n",
-    "  - time_per_page\n",
-    "  - bounce_rate\n",
-    "  - cart_additions\n",
-    "- Introduce the target variable: purchase intent\n",
-    "  - 'purchase_now', 'purchase_later', 'no_purchase'\n",
-    "- Understand data collection methods conceptually (cookies, session logs)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 3.2: Data Loading and Exploration\n",
-    "\n",
-    "In this lesson, we will load a sample browsing dataset and explore it using basic pandas operations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Import libraries\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Load sample data (replace with your path or URL)\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "\n",
-    "# Display first 5 rows\n",
-    "print(data.head())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Show data info and summary statistics\n",
-    "print(\"\\nData Info:\")\n",
-    "print(data.info())\n",
-    "\n",
-    "print(\"\\nSummary Statistics:\")\n",
-    "print(data.describe())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Count unique values in target variable\n",
-    "print('\\nPurchase Intent Distribution:')\n",
-    "print(data['purchase_intent'].value_counts())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Visualize distribution of purchase intent\n",
-    "data['purchase_intent'].value_counts().plot(kind='bar', title='Purchase Intent Distribution')\n",
-    "plt.xlabel('Purchase Intent')\n",
-    "plt.ylabel('Number of Sessions')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Load the `sample_browsing_data.csv` file.\n",
-    "2. Use `.info()` and `.describe()` to understand your dataset.\n",
-    "3. Count how many sessions belong to each purchase intent category.\n",
-    "4. Plot the distribution of a numeric feature (e.g., `session_duration`)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- What do the different columns represent?\n",
-    "- Why do we look at both `.info()` and `.describe()`?\n",
-    "- How is purchase intent labeled if the user doesn't buy immediately?\n",
-    "- How can we trust the quality of collected web browsing data?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_03/Overview.txt

@@ -1,12 +0,0 @@
-Module 3: Understanding the Data
-
-Lesson 3.1: Exploring Web Browsing Behavior Data
-
-o	Typical data fields: session duration, pages visited, time on page, bounce rate, cart additions
-o	Data collection methods (cookies, session logs — conceptual)
-
-Lesson 3.2: Data Loading and Exploration
-
-o	Loading sample browsing data into Pandas
-o	Basic descriptive statistics and visualization
-o	Identifying target variable and features

pages/modules/Module_04/Module_04.ipynb

@@ -1,116 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 4: Data Preprocessing & Feature Engineering\n",
-    "\n",
-    "## Lesson 4.1: Handling Missing Data and Data Cleaning\n",
-    "\n",
-    "- Identify missing values in dataset\n",
-    "- Techniques for handling missing data: dropping, imputing\n",
-    "- Cleaning inconsistent or noisy data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "\n",
-    "# Load sample data\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "\n",
-    "# Check for missing values\n",
-    "print(\"Missing values per column:\")\n",
-    "print(data.isnull().sum())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Fill missing 'session_duration' values with median\n",
-    "median_duration = data['session_duration'].median()\n",
-    "data['session_duration'].fillna(median_duration, inplace=True)\n",
-    "\n",
-    "# Verify no missing values remain in 'session_duration'\n",
-    "print(\"Missing values in 'session_duration' after fill:\", data['session_duration'].isnull().sum())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 4.2: Feature Engineering\n",
-    "\n",
-    "- Creating new features from existing data\n",
-    "- Example: Average time spent per page\n",
-    "- Encoding categorical variables with one-hot encoding"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Create average time spent per page feature\n",
-    "data['avg_time_per_page'] = data['session_duration'] / data['pages_visited']\n",
-    "print(data[['session_duration', 'pages_visited', 'avg_time_per_page']].head())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# One-hot encode 'device_type' categorical feature\n",
-    "data = pd.get_dummies(data, columns=['device_type'], drop_first=True)\n",
-    "\n",
-    "# Show new columns resulting from one-hot encoding\n",
-    "print(data.columns)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Identify columns with missing values and decide how to handle them.\n",
-    "2. Engineer a new feature: \"cart_additions_per_session\" (if you have cart additions data).\n",
-    "3. Convert any other categorical variables in your dataset to one-hot encoded columns."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- When should I fill missing data vs remove rows?\n",
-    "- What are some common strategies for feature engineering?\n",
-    "- Why do we need to one-hot encode categorical variables?\n",
-    "- How can feature engineering improve model performance?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_04/Overview.txt

@@ -1,10 +0,0 @@
-Module 4: Data Preprocessing & Feature Engineering
-
-Lesson 4.1: Handling Missing Data and Data Cleaning
-o	Identifying missing or inconsistent data
-o	Imputing missing values
-
-Lesson 4.2: Feature Engineering
-o	Creating new features from raw browsing data (e.g., average time per page, number of product page visits)
-o	Encoding categorical variables
-o	Feature scaling for ML algorithms

pages/modules/Module_05/Module_05.ipynb

@@ -1,107 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 5: Introduction to Classification and XGBoost\n",
-    "\n",
-    "## Lesson 5.1: Classification Problem\n",
-    "\n",
-    "- Difference between classification and regression\n",
-    "- Introduction to multi-class classification (3 classes: purchase now, purchase later, no purchase)\n",
-    "- Encoding categorical labels as numbers for ML models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "\n",
-    "# Assume data loaded previously\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "\n",
-    "# Show unique classes in target\n",
-    "print(\"Purchase intent classes:\", data['purchase_intent'].unique())\n",
-    "\n",
-    "# Encode target labels numerically\n",
-    "le = LabelEncoder()\n",
-    "data['purchase_intent_encoded'] = le.fit_transform(data['purchase_intent'])\n",
-    "print(data[['purchase_intent', 'purchase_intent_encoded']].head())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 5.2: Introduction to XGBoost\n",
-    "\n",
-    "- What is XGBoost? Tree boosting algorithm often effective for tabular data\n",
-    "- Installation and import\n",
-    "- Basic concepts: boosting, trees, objective function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Install XGBoost if not already installed (uncomment to run in Jupyter)\n",
-    "# !pip install xgboost\n",
-    "\n",
-    "import xgboost as xgb\n",
-    "print(\"XGBoost version:\", xgb.__version__)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Summary:\n",
-    "- We prepare features and labels\n",
-    "- Encode labels for multi-class classification\n",
-    "- Use XGBoost as an effective classifier for predicting purchase intent"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Explore your dataset target classes.\n",
-    "2. Encode the purchase intent column using LabelEncoder.\n",
-    "3. Try installing and importing XGBoost on your system or notebook.\n",
-    "4. Read about XGBoost's key concepts (boosting, trees) from official docs or tutorials."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- Why do we convert labels to numbers?\n",
-    "- What makes XGBoost powerful compared to other classifiers?\n",
-    "- Can XGBoost handle multi-class problems?\n",
-    "- Do we need to preprocess data differently for XGBoost?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_05/Overview.txt

@@ -1,12 +0,0 @@
-Module 5: Introduction to Classification and XGBoost
-
-Lesson 5.1: Classification Problems
-
-o	Defining classification vs regression
-o	Multi-class classification explanation (purchase now, later, no purchase)
-
-Lesson 5.2: Introduction to XGBoost
-
-o	What is XGBoost and why use it?
-o	Boosting concepts and decision trees (simple intuition)
-o	Installing and importing XGBoost in Python

pages/modules/Module_06/Module_06.ipynb

@@ -1,144 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 6: Building the Predictive Model\n",
-    "\n",
-    "## Lesson 6.1: Splitting Data into Train and Test Sets\n",
-    "\n",
-    "- Importance of splitting data to evaluate generalization\n",
-    "- Use scikit-learn's `train_test_split`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "\n",
-    "# Load dataset and encode target if needed\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "le = LabelEncoder()\n",
-    "data['purchase_intent_encoded'] = le.fit_transform(data['purchase_intent'])\n",
-    "\n",
-    "# Define features and target\n",
-    "X = data.drop(columns=['purchase_intent', 'purchase_intent_encoded'])\n",
-    "y = data['purchase_intent_encoded']\n",
-    "\n",
-    "# Split data\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
-    "\n",
-    "print(f\"Training samples: {len(X_train)}\")\n",
-    "print(f\"Test samples: {len(X_test)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 6.2: Training the XGBoost Classifier\n",
-    "\n",
-    "- Initialize XGBoost classifier for multi-class\n",
-    "- Fit model on training data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import xgboost as xgb\n",
-    "\n",
-    "# Initialize model with parameters for multi-class\n",
-    "model = xgb.XGBClassifier(objective='multi:softmax', num_class=3, eval_metric='mlogloss', use_label_encoder=False, seed=42)\n",
-    "\n",
-    "# Train model\n",
-    "model.fit(X_train, y_train)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 6.3: Evaluating Model Performance\n",
-    "\n",
-    "- Predict on test set\n",
-    "- Calculate accuracy and classification report\n",
-    "- Plot confusion matrix"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "\n",
-    "# Predictions\n",
-    "y_pred = model.predict(X_test)\n",
-    "\n",
-    "# Accuracy\n",
-    "acc = accuracy_score(y_test, y_pred)\n",
-    "print(f\"Accuracy on test set: {acc:.2f}\")\n",
-    "\n",
-    "# Classification report\n",
-    "print(\"Classification Report:\")\n",
-    "print(classification_report(y_test, y_pred, target_names=le.classes_))\n",
-    "\n",
-    "# Confusion matrix\n",
-    "cm = confusion_matrix(y_test, y_pred)\n",
-    "plt.figure(figsize=(7,5))\n",
-    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=le.classes_, yticklabels=le.classes_)\n",
-    "plt.xlabel('Predicted Label')\n",
-    "plt.ylabel('True Label')\n",
-    "plt.title('Confusion Matrix')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Split your dataset into train/test sets with 80/20 ratio.\n",
-    "2. Initialize and train an XGBoost classifier with multi-class support.\n",
-    "3. Compute test accuracy and plot the confusion matrix.\n",
-    "4. Experiment with different random states and observe accuracy changes."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- Why do we split data and not train on the entire set?\n",
-    "- What is the confusion matrix and how do we interpret it?\n",
-    "- What is multi-class softmax objective in XGBoost?\n",
-    "- How do parameters like `random_state` affect results?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_06/Overview.txt

@@ -1,15 +0,0 @@
-Module 6: Building the Predictive Model
-
-Lesson 6.1: Splitting Data into Train and Test Sets
-
-o	Purpose of train-test split
-o	Using scikit-learn’s train_test_split
-
-Lesson 6.2: Training the XGBoost Classifier
-o	Configuring XGBoost parameters for multi-class classification
-o	Fitting the model to training data
-
-Lesson 6.3: Evaluating Model Performance
-o	Accuracy, precision, recall, F1-score basics
-o	Confusion matrix explanation and visualization
-o	Introduction to cross-validation (concept overview)

pages/modules/Module_07/Module_07.ipynb

@@ -1,91 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 7: Feature Importance and Model Interpretation\n",
-    "\n",
-    "## Lesson 7.1: Understanding Feature Importance\n",
-    "\n",
-    "- Why feature importance matters\n",
-    "- How XGBoost calculates feature importance (weight, gain, cover)\n",
-    "- Visualizing feature importance"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import xgboost as xgb\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Load dataset and train model (reuse from Module 6)\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "le = LabelEncoder()\n",
-    "data['purchase_intent_encoded'] = le.fit_transform(data['purchase_intent'])\n",
-    "X = data.drop(columns=['purchase_intent', 'purchase_intent_encoded'])\n",
-    "y = data['purchase_intent_encoded']\n",
-    " \n",
-    "from sklearn.model_selection import train_test_split\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
-    "\n",
-    "model = xgb.XGBClassifier(objective='multi:softmax', num_class=3, use_label_encoder=False, eval_metric='mlogloss', seed=42)\n",
-    "model.fit(X_train, y_train)\n",
-    "\n",
-    "# Plot feature importance\n",
-    "xgb.plot_importance(model, max_num_features=10, importance_type='gain')\n",
-    "plt.title('Top 10 Feature Importances (Gain)')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 7.2: Using Feature Importance for Insights\n",
-    "\n",
-    "- Understand which features drive purchase intent predictions\n",
-    "- Discuss practical applications of feature importance (marketing, product design)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Plot the feature importance of your dataset’s model.\n",
-    "2. Identify the top 5 features and suggest why they might be important.\n",
-    "3. Write a short paragraph explaining how you’d use these insights in a business context."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- What does 'gain' mean in feature importance?\n",
-    "- Are feature importance scores always reliable?\n",
-    "- Can feature importance tell us about causality?\n",
-    "- How to handle features that appear unimportant?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_07/Overview.txt

@@ -1,12 +0,0 @@
-Module 7: Feature Importance and Model Interpretation
-
-Lesson 7.1: Understanding Feature Importance
-
-o	Why feature importance matters
-o	How XGBoost calculates feature importance (gain, cover, weight)
-o	Plotting feature importance with XGBoost built-in functions and external libraries (Matplotlib, SHAP overview)
-
-Lesson 7.2: Using Feature Importance for Insights
-
-o	Identifying key drivers of purchase intent
-o	Practical implications for marketing strategies or UI improvements

pages/modules/Module_08/Module_08.ipynb

@@ -1,124 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 8: Dimensionality Reduction and Feature Selection\n",
-    "\n",
-    "## Lesson 8.1: Why Reduce Features?\n",
-    "- Discuss curse of dimensionality and computational cost\n",
-    "- Benefits: faster training, reduced noise, easier visualization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 8.2: Principal Component Analysis (PCA)\n",
-    "- Introduce PCA concept: transform features into uncorrelated principal components\n",
-    "- Apply PCA to scaled data\n",
-    "- Plot explained variance to identify how many components to keep"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Load dataset\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "X = data.drop(columns=['purchase_intent'])\n",
-    "\n",
-    "# Some preprocessing: handle missing, drop non-numeric if needed\n",
-    "X = X.select_dtypes(include=[np.number])\n",
-    "X.fillna(X.median(), inplace=True)\n",
-    "\n",
-    "# Scale features\n",
-    "scaler = StandardScaler()\n",
-    "X_scaled = scaler.fit_transform(X)\n",
-    "\n",
-    "# Apply PCA\n",
-    "pca = PCA()\n",
-    "pca.fit(X_scaled)\n",
-    "\n",
-    "# Plot cumulative explained variance\n",
-    "plt.figure(figsize=(8,5))\n",
-    "plt.plot(np.cumsum(pca.explained_variance_ratio_))\n",
-    "plt.xlabel('Number of Principal Components')\n",
-    "plt.ylabel('Cumulative Explained Variance')\n",
-    "plt.title('PCA - Explained Variance vs Number of Components')\n",
-    "plt.grid(True)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 8.3: The Elbow Method for Feature Selection\n",
-    "- Use the \"elbow\" in explained variance plot to decide how many components to keep\n",
-    "- Dimensionality reduction improves model speed and may improve accuracy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Example: choose number of components that explain at least 90% variance\n",
-    "cumulative_variance = np.cumsum(pca.explained_variance_ratio_)\n",
-    "n_components_90 = np.argmax(cumulative_variance >= 0.90) + 1\n",
-    "print(f\"Number of components to explain 90% variance: {n_components_90}\")\n",
-    "\n",
-    "# Transform data with selected components\n",
-    "pca_selected = PCA(n_components=n_components_90)\n",
-    "X_reduced = pca_selected.fit_transform(X_scaled)\n",
-    "print(f\"Shape of reduced data: {X_reduced.shape}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Perform PCA on your dataset features.\n",
-    "2. Plot and interpret the explained variance curve.\n",
-    "3. Choose the number of components using the elbow method.\n",
-    "4. Transform your dataset into the reduced PCA space."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- What does each principal component represent?\n",
-    "- Should we always reduce dimensionality?\n",
-    "- How to decide how many components to keep?\n",
-    "- Does PCA guarantee better model accuracy?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_08/Overview.txt

@@ -1,17 +0,0 @@
-Module 8: Dimensionality Reduction and Feature Selection
-
-Lesson 8.1: Why Reduce Features?
-
-o	Curse of dimensionality and model complexity
-o	Benefits of dimensionality reduction
-
-Lesson 8.2: Principal Component Analysis (PCA)
-
-o	Intuition of PCA—capturing variance in fewer dimensions
-o	Applying PCA to browsing features
-o	Visualizing principal components
-
-Lesson 8.3: The Elbow Method for Feature Selection
-
-o	Concept of the elbow method to decide number of components or clusters
-o	Plotting explained variance ratio to select dimension count

pages/modules/Module_09/Module_09.ipynb

@@ -1,157 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 9: Clustering and User Segmentation\n",
-    "\n",
-    "## Lesson 9.1: Introduction to Unsupervised Learning and Clustering\n",
-    "\n",
-    "- Difference between supervised and unsupervised learning\n",
-    "- Why cluster users? To find natural groupings for marketing and personalization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 9.2: K-Means Clustering\n",
-    "\n",
-    "- How K-Means works: Iterative cluster assignment and centroid updates\n",
-    "- Choosing number of clusters (k) using elbow method"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from sklearn.cluster import KMeans\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Load dataset\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "\n",
-    "# Select numeric features for clustering\n",
-    "X = data.select_dtypes(include=[np.number])\n",
-    "X.fillna(X.median(), inplace=True)\n",
-    "\n",
-    "# Scale features\n",
-    "scaler = StandardScaler()\n",
-    "X_scaled = scaler.fit_transform(X)\n",
-    "\n",
-    "# Elbow method to find optimal k\n",
-    "inertia = []\n",
-    "k_range = range(1, 11)\n",
-    "for k in k_range:\n",
-    "    kmeans = KMeans(n_clusters=k, random_state=42)\n",
-    "    kmeans.fit(X_scaled)\n",
-    "    inertia.append(kmeans.inertia_)\n",
-    "\n",
-    "plt.figure(figsize=(8,5))\n",
-    "plt.plot(k_range, inertia, 'bo-')\n",
-    "plt.xlabel('Number of clusters k')\n",
-    "plt.ylabel('Inertia (Sum of squared distances)')\n",
-    "plt.title('Elbow Method For Optimal k')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 9.3: Analyzing and Labeling Segments\n",
-    "\n",
-    "- Choose number of clusters (e.g., k=3)\n",
-    "- Fit K-Means and assign cluster labels\n",
-    "- Analyze cluster centers and interpret user behaviors"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "k_optimal = 3\n",
-    "kmeans = KMeans(n_clusters=k_optimal, random_state=42)\n",
-    "data['cluster'] = kmeans.fit_predict(X_scaled)\n",
-    "\n",
-    "# Display cluster counts\n",
-    "print(data['cluster'].value_counts())\n",
-    "\n",
-    "# Calculate cluster centers (in scaled space)\n",
-    "centers = kmeans.cluster_centers_\n",
-    "\n",
-    "# Convert centers back to original scale for interpretation\n",
-    "centers_orig = scaler.inverse_transform(centers)\n",
-    "centers_df = pd.DataFrame(centers_orig, columns=X.columns)\n",
-    "print(\"Cluster Centers (approximate feature means):\")\n",
-    "print(centers_df)\n",
-    "\n",
-    "# Visualize clusters using first two principal components (optional)\n",
-    "from sklearn.decomposition import PCA\n",
-    "pca = PCA(n_components=2)\n",
-    "X_pca = pca.fit_transform(X_scaled)\n",
-    "\n",
-    "plt.figure(figsize=(8,6))\n",
-    "plt.scatter(X_pca[:,0], X_pca[:,1], c=data['cluster'], cmap='viridis', alpha=0.6)\n",
-    "plt.xlabel('PCA Component 1')\n",
-    "plt.ylabel('PCA Component 2')\n",
-    "plt.title('User Clusters Visualization (PCA)')\n",
-    "plt.colorbar(label='Cluster')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 9.4: Using Clusters to Enhance Purchase Predictions\n",
-    "\n",
-    "- Discuss adding cluster assignments as a feature to classifiers\n",
-    "- Segment-specific marketing strategies\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Apply K-Means clustering to your browsing data.\n",
-    "2. Use the elbow method to select an optimal number of clusters.\n",
-    "3. Analyze and describe characteristics of each cluster.\n",
-    "4. Visualize the clusters on 2D PCA components."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- How does K-Means assign clusters?\n",
-    "- What if clusters are not well separated?\n",
-    "- Can we use other clustering methods?\n",
-    "- How do clusters improve prediction or marketing?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pages/modules/Module_09/Overview.txt

@@ -1,18 +0,0 @@
-Module 9: Clustering and User Segmentation
-
-Lesson 9.1: Introduction to Unsupervised Learning and Clustering
-
-o	Difference between supervised and unsupervised learning
-o	Use cases for clustering in e-commerce (user segmentation, personalized marketing)
-
-Lesson 9.2: K-Means Clustering
-o	How K-Means works conceptually
-o	Applying K-Means on browsing behavior features
-o	Finding optimal number of clusters (using elbow method)
-
-Lesson 9.3: Analyzing and Labeling Segments
-o	Profiling clusters based on feature averages
-o	Assigning marketing personas or labels (e.g., window shoppers, deal hunters, loyal customers)
-
-Lesson 9.4: Using Clusters to Enhance Purchase Predictions
-o	Combining clustering results as new features or separate workflows

pages/modules/Module_10/Module_10.ipynb

@@ -1,119 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Module 10: Advanced Model Improvement and Ethical Considerations\n",
-    "\n",
-    "## Lesson 10.1: Hyperparameter Tuning and Handling Class Imbalance\n",
-    "\n",
-    "- Importance of tuning model hyperparameters to improve performance\n",
-    "- Overview of Grid Search and Random Search\n",
-    "- Handling class imbalance: resampling, class weights\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "import xgboost as xgb\n",
-    "\n",
-    "# Load and prepare data\n",
-    "data = pd.read_csv('sample_browsing_data.csv')\n",
-    "le = LabelEncoder()\n",
-    "data['purchase_intent_encoded'] = le.fit_transform(data['purchase_intent'])\n",
-    "\n",
-    "X = data.drop(columns=['purchase_intent', 'purchase_intent_encoded'])\n",
-    "y = data['purchase_intent_encoded']\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
-    "\n",
-    "# Define model\n",
-    "model = xgb.XGBClassifier(objective='multi:softmax', num_class=3, use_label_encoder=False, eval_metric='mlogloss', seed=42)\n",
-    "\n",
-    "# Hyperparameter grid\n",
-    "param_grid = {\n",
-    "    'max_depth': [3, 5],\n",
-    "    'learning_rate': [0.1, 0.01],\n",
-    "    'n_estimators': [50, 100]\n",
-    "}\n",
-    "\n",
-    "# Setup GridSearchCV\n",
-    "grid_search = GridSearchCV(model, param_grid, cv=3, scoring='accuracy', verbose=1)\n",
-    "\n",
-    "# Fit grid search\n",
-    "grid_search.fit(X_train, y_train)\n",
-    "\n",
-    "print(f\"Best parameters: {grid_search.best_params_}\")\n",
-    "print(f\"Best cross-validation accuracy: {grid_search.best_score_:.2f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Handling Class Imbalance (Conceptual)\n",
-    "\n",
-    "- Techniques:\n",
-    "  - Oversampling minority class\n",
-    "  - Undersampling majority class\n",
-    "  - Using class weights in model training\n",
-    "- XGBoost supports scale_pos_weight parameter for binary imbalance (multi-class requires other approaches)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lesson 10.2: Ethical Considerations in ML for E-Commerce\n",
-    "\n",
-    "- **Privacy:** Ethical collection and use of browsing data\n",
-    "- **Bias and fairness:** Avoid reinforcing stereotypes or discrimination\n",
-    "- **Transparency:** Explainability of ML predictions\n",
-    "- **User consent:** Informing users how data is used\n",
-    "\n",
-    "Discuss examples and best practices."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercises:\n",
-    "1. Perform hyperparameter tuning on your XGBoost model using GridSearchCV.\n",
-    "2. Research techniques to handle class imbalance and describe which might fit e-commerce data.\n",
-    "3. Write a paragraph on ethical issues you foresee in using ML to predict purchase intent."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Potential Student Questions:\n",
-    "- How do hyperparameters affect model performance?\n",
-    "- What happens if classes are imbalanced?\n",
-    "- How can models be made fair and unbiased?\n",
-    "- What are real risks of privacy violations?"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.x"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}