Upload 35 files

.gitattributes

@@ -39,3 +39,13 @@ assets/thumbs_up.gif filter=lfs diff=lfs merge=lfs -text
 assets/TOK.jpg filter=lfs diff=lfs merge=lfs -text
 pages/assets/ascend.mp4 filter=lfs diff=lfs merge=lfs -text
 pages/assets/juicy_fruit.mp3 filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_01/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_02/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_03/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_04/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_05/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_06/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_07/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_08/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_09/Overview.jpg filter=lfs diff=lfs merge=lfs -text
+pages/modules/Module_10/Overview.jpg filter=lfs diff=lfs merge=lfs -text

pages/modules/Module_01/Module_01.ipynb

@@ -0,0 +1,90 @@
+{
+ "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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,158 @@
+{
+ "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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,122 @@
+{
+ "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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,116 @@
+{
+ "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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,107 @@
+{
+ "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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,144 @@
+{
+ "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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,91 @@
+{
+ "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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,124 @@
+{
+ "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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,157 @@
+{
+ "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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,119 @@
+{
+ "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
+}

pages/modules/Module_10/Overview.txt

@@ -0,0 +1,17 @@
+Module 10: Advanced Model Improvements
+
+Lesson 7.1: Hyperparameter Tuning
+
+o	Concepts of hyperparameters (learning rate, max_depth, etc.)
+o	Grid search or random search (concept overview)
+
+Lesson 7.2: Handling Class (Data) Imbalances
+
+o	What is class imbalance?
+o	Techniques to address imbalance (resampling, class weights)
+
+Lesson 7.3 
+
+o	Discussions on explainability with SHAP or LIME (optional)
+
+

pages/modules/Module_11/Overview.txt

@@ -0,0 +1,16 @@
+Module 11 An Actual Application and Deployment
+
+Lesson 11.1: Running your own real prediction application on real data
+
+Students will go through the entire pipeline:
+
+o	Load and preprocess a provided browsing dataset
+o	Engineer relevant features
+o	Train and evaluate an XGBoost classifier
+o	Interpret the results and discuss practical implications
+
+Lesson 11.2: Ethical Considerations
+
+o	Privacy concerns with user data
+o	Fairness and bias in predictions
+o	Transparency and explainability of ML models

pages/modules/Overview/Overview.txt

@@ -0,0 +1,15 @@
+Welcome to "Will They Buy It"
+
+Select the first module using the sidebar on the left
+
+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