Drop stray Jupyter checkpoint copies

.ipynb_checkpoints/README-checkpoint.md

@@ -1,159 +0,0 @@
-# Introduction to AI — Practical Exam Grading Dataset (Stage 2)
-
-1,038 anonymized student submissions to a university-level practical AI exam,
-each independently graded by **two** teaching assistants, plus the rubric and
-the instructor reference solutions.
-
-The 18 LLM grading runs measured on this data, the graders that produced them,
-and the analysis code all live in the project repository alongside the
-equivalent Computer Vision dataset; this folder is the data itself.
-
-The dataset was built to test how sensitive LLM graders are to the *prompt* they
-are given — specifically, what happens when an instructor adds a plausible
-"be strict" instruction to an otherwise well-behaved grading prompt.
-
-## What is here
-
-| path | contents |
-|---|---|
-| `Practical_AI_exam_grades.csv` | ground truth: two TA grades per student, per question and total |
-| `submissions_extracted/<n>/Q{1,2,3}.ipynb` | the anonymized student notebooks |
-| `Solutions/` | instructor reference solution per question |
-| `stage_2_rubrics_ta.md` | the marking scheme the TAs graded against |
-
-Students are identified only by a number (1–1038) that is stable across every
-file. Notebook `submissions_extracted/7/Q2.ipynb` belongs to the student in row
-`Number == 7` of the grades CSV.
-
-## The exam and its scale
-
-Three questions: **Q1** tabular regression (predict food delivery time),
-**Q2** PyTorch (predict age from face images), **Q3** classification (find the
-most predictive feature in an anonymized dataset).
-
-Marks come from the rubric's task tables, not its header totals — the two
-disagree in the distributed PDF, which is preserved here as `stage_2_rubrics_ta.md`:
-
-| question | base | bonus |
-|---|---|---|
-| Q1 Regression | 23 | 3 |
-| Q2 PyTorch | 14 | 3 |
-| Q3 Classification | 19 | 3 |
-
-Two instructor corrections were issued by email *during* grading, both affecting
-Q3 only (Part 1 dropped a task and became 2 marks; Part 4 dropped a task and
-became 5). Both are folded into the rubric file and marked ⚠.
-
-## Ground truth quality
-
-Every student is graded by two TAs, so the dataset carries its own noise floor:
-
-| statistic | value |
-|---|---|
-| TA-vs-TA mean absolute difference (totals) | 5.13 |
-| **floor: \|TA − TA mean\|**, the quantity an AI grader is scored against | **2.57** (95% CI 2.41–2.74) |
-| inter-TA correlation (totals) | 0.871 |
-
-The floor is ~4% of the ~65-point scale. Any AI grader should be read against
-2.57, not against zero.
-
-## Anonymization
-
-Student names, ID numbers, emails, and submission links are absent. Notebooks
-were rebuilt from scratch keeping only code cells: markdown cells, outputs,
-execution counts, and all per-cell metadata were dropped, so Colab
-`executionInfo` blocks (which embed a Google account name and user id) do not
-survive. Remaining identifiers inside code — names in variable names or
-comments, emails, ID numbers, phone numbers, filesystem usernames — were
-replaced with `ANON` (identifier-safe) or `[REDACTED]`.
-
-Scrubbing was verified two ways: an exhaustive scan against the full roster
-(every student and TA name, email and ID, plus generic email/ID/phone patterns
-and notebook-format regressions), and an LLM review of all ~25k comment and
-string literals looking for identifiers the roster could not know about. The
-second pass is what caught a reference to an instructor by first name and one
-student who had loaded the exam data from a personal account.
-
-TAs appear only as pseudonyms (`TA_1`, `TA_2`, …). One slot carries the
-composite id `TA_49+TA_50`: those 18 students had Q1 and Q2 graded by one TA and
-Q3 by another. The pseudonym-to-person mapping is **not** published, so grading
-behaviour cannot be attributed to any individual.
-
-One deliberate difference between the released grader and the script that
-produced `results/`: the prompt's opening sentence named the institution and
-programme running the course, and reads *"an introductory AI practical exam"*
-here instead. That phrase is the only difference, and it changes no grading
-rule — but a run reproduced from this bundle sends a prompt one phrase
-different from the published one.
-
-## Known gaps, stated plainly
-
-- 24 students from the original cohort are absent: they uploaded nothing, an
-  unreadable archive, or files that were not the exam. The remaining 1,038 are
-  numbered contiguously.
-- Roughly 96 students are missing a notebook for at least one question — they
-  did not submit that question. An absent `Q<n>.ipynb` means exactly that, and
-  the grading code scores it 0.
-- The rubric's header totals contradict its own task tables in all three
-  questions. This is preserved rather than corrected; it is part of what a real
-  grading prompt has to cope with.
-- A handful of TA grades exceed the rubric maximum for a question.
-- Two TA grades awarded credit for a question the student never submitted
-  (8.0 and 10.0, each contradicted by the paired TA's 0). Both were set to 0
-  and the totals recomputed: ground truth that credits work no grader can see
-  would penalise every grader, human or machine.
-
-## The LLM runs in `results/`
-
-Nine open-weights models, each run twice over the full cohort with an identical
-prompt except for one leading persona sentence:
-
-- **neutral** — "You are a strict but fair teaching assistant."
-- **strict** — "You are a HARSH teaching assistant. Award the MINIMUM defensible
-  score for any task that is incomplete, buggy, or deviates from the rubric.
-  Never give partial credit if the task does not run correctly."
-
-Everything else is held fixed: reference solution included, per-task breakdown
-requested, no chain-of-thought, temperature 0, one sample per question. Each
-workbook holds the AI score, bonus, and reasoning per question alongside the TA
-columns. `runs_summary.csv` carries MAE against the TA average with a
-2,000-resample bootstrap CI.
-
-`behaviour` classes: `refusal` (≥90% of students zeroed, awarded-total std
-< 0.5), `near-refusal` (≥90% zeroed but still varying), `collapse` (MAE ≥ 8,
-i.e. ≥3× the human floor, while still discriminating between students),
-`graded` otherwise.
-
-## Reproducing
-
-The grading and analysis code lives in the project repository, which expects
-this folder at `introduction_to_ai_dataset/`:
-
-```bash
-# serve a model with vLLM, then:
-python introduction_to_ai_grade_with_local.py --all \
-  --model <hf-model-id> --api-base http://localhost:8000/v1 \
-  --with-solution --no-reasoning --with-breakdown \
-  --strictness strict --temperature 0.0 --runs 1 \
-  --tag IA02_m-<model_tag>_sol1_gd0_rs0_bd1_str-strict_t00_n1
-
-python introduction_to_ai_analyze_run.py <model_tag>   # MAE, CI, behaviour class
-```
-
-`introduction_to_ai_submit_persona_sweep.sbatch` is the SLURM launcher: an
-array job, one task per persona (`--array=0,1` gives the published
-neutral+strict pair). `STUDENTS=1-5` turns it into a smoke run that writes
-outside the results tree. It also supports splitting one persona across
-`SHARDS=K` concurrent jobs, reassembled with
-`introduction_to_ai_merge_shards.py`.
-Shards must never share an output workbook — the grader holds the whole workbook
-in memory and rewrites it after every question, so two writers silently destroy
-each other's grades.
-
-The published runs used vLLM 0.19.1. Grading is not bitwise reproducible:
-generation is unconstrained, and JSON is parsed leniently.
-
-## Licence and intended use
-
-The student work belongs to its authors and is released for research on
-automated grading. Do not attempt to re-identify students or TAs.

Solutions/.ipynb_checkpoints/Q1_Regression_Solution-checkpoint.ipynb

@@ -1,331 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Question 1 SOLUTION: Predict Food Delivery Time\n",
-    "\n",
-    "You are provided with a food delivery dataset that includes features such as delivery distance, restaurant preparation time, traffic conditions, and order details. Your objective is to develop a regression model that accurately predicts the delivery time in minutes.\n",
-    "\n",
-    "Your target is the column: \"delivery_time\".\n",
-    "\n",
-    "You are provided with the code to download and load the csv file.\n",
-    "\n",
-    "Your work will be evaluated based on the completion of the following tasks:\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 1: Read Data\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "1. Read the dataset using `read_csv()`\n",
-    "2. Inspect the first few rows using `head()`\n",
-    "3. Display dataset information using `info()`\n",
-    "4. Show statistical description using `describe()`\n",
-    "5. Plot the target distribution (delivery_time)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import kagglehub\n",
-    "\n",
-    "# Download latest version\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q1-ka-ai-2026\")\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import pandas as pd\n",
-    "import os\n",
-    "df = pd.read_csv(os.path.join(path, 'Q1_data.csv'))\n",
-    "df.head()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.head()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.info()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.describe()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df['Delivery_Time'].hist(bins=30)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 2: Data Cleaning\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "Inspect and fix the following when needed:\n",
-    "\n",
-    "1. **Drop the 'Order_ID' column from the data** \n",
-    "2. **Handle missing values appropriately** (Hint: I guess you want to have a closer look at the columns with missing values :) )\n",
-    "3. **Check and remove duplicates** if any exist\n",
-    "4. **Encode categorical variables** if needed\n",
-    "5. **Apply feature scaling** to numerical features (Use StandardScaler)\n",
-    "6. **Check for target imbalance and state if it is imbalanced or not** (keep this cell empty if not needed)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1\n",
-    "df = df.drop('Order_ID', axis=1)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2\n",
-    "# Drop rows with missing target\n",
-    "df = df.dropna(subset=['Delivery_Time'])\n",
-    "# Fill missing values\n",
-    "df = df.fillna(df.median(numeric_only=True))\n",
-    "df = df.fillna(df.mode().iloc[0])"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3\n",
-    "df = df.drop_duplicates()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "categorical_cols = df.select_dtypes(\"object\").columns\n",
-    "for col in categorical_cols:\n",
-    "    le = LabelEncoder()\n",
-    "    df[col] = le.fit_transform(df[col])"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 5\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "scaler = StandardScaler()\n",
-    "X_cols = [col for col in df.columns if col != 'Delivery_Time']\n",
-    "df[X_cols] = scaler.fit_transform(df[X_cols])"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 6\n",
-    "# Not applicable for regression"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 3: Modeling\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "1. Split the dataset into features (X) and target (y)\n",
-    "2. Use the correct split: **KFold** OR **StratifiedKFold**\n",
-    "3. Train a **RandomForest** model\n",
-    "4. Evaluate using **MAE (Mean Absolute Error) ONLY**\n",
-    "5. Print the averaged score across all folds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "X = df.drop('Delivery_Time', axis=1)\n",
-    "y = df['Delivery_Time']"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.model_selection import KFold\n",
-    "from sklearn.ensemble import RandomForestRegressor\n",
-    "from sklearn.metrics import mean_absolute_error\n",
-    "import numpy as np\n",
-    "\n",
-    "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
-    "model = RandomForestRegressor(random_state=42)\n",
-    "scores = []\n",
-    "\n",
-    "for train_idx, val_idx in kf.split(X):\n",
-    "    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n",
-    "    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n",
-    "    model.fit(X_train, y_train)\n",
-    "    y_pred = model.predict(X_val)\n",
-    "    scores.append(mean_absolute_error(y_val, y_pred))\n",
-    "\n",
-    "print(f'Average MAE: {np.mean(scores):.2f}')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 4: Plots\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "1. Plot feature importance from your trained model\n",
-    "2. Plot predicted delivery time histogram"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "plt.barh(X.columns, model.feature_importances_)\n",
-    "plt.xlabel('Importance')\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "y_pred = model.predict(X)\n",
-    "plt.hist(y_pred, bins=30)\n",
-    "plt.xlabel('Predicted Delivery Time')\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 5: Bonus - Ensemble\n",
-    "\n",
-    "**Task:**\n",
-    "\n",
-    "Why use one model? Let's use 2 then merge!\n",
-    "\n",
-    "Rewrite the KFold loop such that you:\n",
-    "1. Train **2 different models** inside the loop at the same time in each iteration\n",
-    "2. Average their predictions\n",
-    "3. Calculate the MAE metric on the averaged predictions\n",
-    "\n",
-    "Use RandomForestRegressor and CatBoostRegressor."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.ensemble import RandomForestRegressor\n",
-    "from catboost import CatBoostRegressor\n",
-    "\n",
-    "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
-    "model1 = RandomForestRegressor(random_state=42)\n",
-    "model2 = CatBoostRegressor(verbose=0, random_state=42)\n",
-    "scores = []\n",
-    "\n",
-    "for train_idx, val_idx in kf.split(X):\n",
-    "    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n",
-    "    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n",
-    "    \n",
-    "    model1.fit(X_train, y_train)\n",
-    "    model2.fit(X_train, y_train)\n",
-    "    \n",
-    "    y_pred1 = model1.predict(X_val)\n",
-    "    y_pred2 = model2.predict(X_val)\n",
-    "    y_pred_avg = (y_pred1 + y_pred2) / 2\n",
-    "    \n",
-    "    scores.append(mean_absolute_error(y_val, y_pred_avg))\n",
-    "\n",
-    "print(f'Average MAE (Ensemble): {np.mean(scores):.2f}')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

Solutions/.ipynb_checkpoints/Q2_Pytorch_Solution-checkpoint.ipynb

@@ -1,396 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Question 2: Predict Age from Face Images\n",
-    "\n",
-    "You are provided with a face image dataset containing 2000 images of human faces. Your objective is to develop a regression model using PyTorch that accurately predicts the age of a person based on their face image.\n",
-    "\n",
-    "You are provided with the code to download and load the dataset.\n",
-    "\n",
-    "Your work will be evaluated based on the completion of the following tasks:\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 1. Load and Process Data (Provided)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### **1. Load and Process Data (Provided)**\n",
-    "\n",
-    "The code below is provided for you. It:\n",
-    "1.  Loads images from the `images` folder.\n",
-    "2.  Loads labels from `labels.csv`.\n",
-    "3.  Splits the data into training and testing sets (`X_train`, `X_test`, `y_train`, `y_test`).\n",
-    "\n",
-    "**Just run these cell to load the data.**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import kagglehub\n",
-    "\n",
-    "# Download latest version\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q2-ka-ai-2026\")\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import os\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from PIL import Image\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "\n",
-    "# Load Labels\n",
-    "labels_df = pd.read_csv(os.path.join(path, \"labels.csv\"))\n",
-    "img_dir = os.path.join(path, \"images\")\n",
-    "\n",
-    "images = []\n",
-    "ages = []\n",
-    "\n",
-    "# Load Images and Resize\n",
-    "print(\"Loading images...\")\n",
-    "for index, row in labels_df.iterrows():\n",
-    "    img_name = row.iloc[0]\n",
-    "    age = row.iloc[1]\n",
-    "    img_path = os.path.join(img_dir, img_name)\n",
-    "    \n",
-    "    if os.path.exists(img_path):\n",
-    "        img = Image.open(img_path).convert('RGB')\n",
-    "        img_array = np.array(img) / 255.0 # Normalize pixel values to [0, 1]\n",
-    "        images.append(img_array)\n",
-    "        ages.append(age)\n",
-    "\n",
-    "X = np.array(images)\n",
-    "y = np.array(ages)\n",
-    "\n",
-    "# Transpose image dimensions to match PyTorch format (N, C, H, W)\n",
-    "X = np.transpose(X, (0, 3, 1, 2))\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\"X_train shape: {X_train.shape}\")\n",
-    "print(f\"X_test shape: {X_test.shape}\")\n",
-    "print(f\"y_train shape: {y_train.shape}\")\n",
-    "print(f\"y_test shape: {y_test.shape}\")"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## **Part 1: Prepare Data for PyTorch**\n",
-    "\n",
-    "**Tasks:**\n",
-    "1.  **Convert to Tensors:** Convert the numpy arrays (`X_train`, `X_test`, `y_train`, `y_test`) into PyTorch tensors.\n",
-    "2.  **Create Datasets:** Use `TensorDataset` to create `train_dataset` and `test_dataset` from the tensors.\n",
-    "3.  **Create DataLoaders:** Create `train_loader` and `test_loader` with a batch size of 32. \n",
-    "4.  **Inspect Data:** Print the shape of one batch from the train loader and \n",
-    "5.  **Display a few images:** Use matplotlib to display a few images."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import torch\n",
-    "\n",
-    "X_train_tensor = torch.tensor(X_train, dtype=torch.float32)\n",
-    "X_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n",
-    "y_train_tensor = torch.tensor(y_train, dtype=torch.float32)\n",
-    "y_test_tensor = torch.tensor(y_test, dtype=torch.float32)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from torch.utils.data import TensorDataset\n",
-    "\n",
-    "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
-    "test_dataset = TensorDataset(X_test_tensor, y_test_tensor)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from torch.utils.data import DataLoader\n",
-    "\n",
-    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
-    "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "images, labels = next(iter(train_loader))\n",
-    "print(f\"Batch images shape: {images.shape}\")\n",
-    "print(f\"Batch labels shape: {labels.shape}\")"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "plt.figure(figsize=(10, 5))\n",
-    "for i in range(4):\n",
-    "    plt.subplot(1, 4, i+1)\n",
-    "    img = images[i].permute(1, 2, 0).numpy()\n",
-    "    plt.imshow(img)\n",
-    "    plt.title(f\"Age: {labels[i].item():.0f}\")\n",
-    "    plt.axis(\"off\")\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 2: Model\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "1. Create a model class with **4 linear layers**\n",
-    "2. Create a training loop function\n",
-    "3. Create a validation loop function\n",
-    "4. Define the device, model, loss function, and optimizer\n",
-    "5. Start training for **20 epochs** and track training and validation losses"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import torch.nn as nn\n",
-    "\n",
-    "class AgeModel(nn.Module):\n",
-    "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
-    "        super(AgeModel, self).__init__()\n",
-    "        self.layer1 = nn.Linear(input_dim, hidden_dim)\n",
-    "        self.layer2 = nn.Linear(hidden_dim, hidden_dim)\n",
-    "        self.layer3 = nn.Linear(hidden_dim, hidden_dim)\n",
-    "        self.layer4 = nn.Linear(hidden_dim, output_dim)\n",
-    "        self.relu = nn.ReLU()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.relu(self.layer1(x))\n",
-    "        x = self.relu(self.layer2(x))\n",
-    "        x = self.relu(self.layer3(x))\n",
-    "        x = self.layer4(x)\n",
-    "        return x.squeeze()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "def train_one_epoch(model, optimizer, criterion, train_loader, device):\n",
-    "    # Set the model to training mode\n",
-    "    model.train()\n",
-    "\n",
-    "    running_loss = 0.0\n",
-    "\n",
-    "    for X_batch, y_batch in train_loader:\n",
-    "        # Move batch to the selected device\n",
-    "        X_batch = X_batch.view(X_batch.size(0), -1).to(device)\n",
-    "        y_batch = y_batch.to(device)\n",
-    "\n",
-    "        # Forward pass\n",
-    "        outputs = model(X_batch)\n",
-    "        loss = criterion(outputs, y_batch)\n",
-    "\n",
-    "        # Backward pass & optimization\n",
-    "        optimizer.zero_grad()   # Clear previous gradients\n",
-    "        loss.backward()         # Compute gradients\n",
-    "        optimizer.step()        # Update model parameters\n",
-    "\n",
-    "        running_loss += loss.item()\n",
-    "\n",
-    "    # Average loss over all batches\n",
-    "    avg_loss = running_loss / len(train_loader)\n",
-    "\n",
-    "    return avg_loss"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "def validate(model, criterion, test_loader, device):\n",
-    "    # Set the model to evaluation mode\n",
-    "    model.eval()\n",
-    "\n",
-    "    running_loss = 0.0\n",
-    "\n",
-    "    with torch.no_grad():\n",
-    "        for X_batch, y_batch in test_loader:\n",
-    "            # Move data to device\n",
-    "            X_batch = X_batch.view(X_batch.size(0), -1).to(device)\n",
-    "            y_batch = y_batch.to(device)\n",
-    "\n",
-    "            # Forward pass\n",
-    "            outputs = model(X_batch)\n",
-    "            loss = criterion(outputs, y_batch)\n",
-    "            running_loss += loss.item()\n",
-    "\n",
-    "    avg_loss = running_loss / len(test_loader)\n",
-    "\n",
-    "    return avg_loss"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "\n",
-    "input_dim = 36 * 36 * 3\n",
-    "hidden_dim = 128\n",
-    "output_dim = 1\n",
-    "\n",
-    "model = AgeModel(input_dim, hidden_dim, output_dim).to(device)\n",
-    "\n",
-    "num_epochs = 20\n",
-    "learning_rate = 0.001\n",
-    "\n",
-    "criterion = nn.MSELoss()\n",
-    "optimizer = torch.optim.AdamW(model.parameters(), learning_rate)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Run Training\n",
-    "train_losses = []\n",
-    "val_losses = []\n",
-    "\n",
-    "print('Starting Training...')\n",
-    "for epoch in range(num_epochs):\n",
-    "    # Train one epoch\n",
-    "    train_loss = train_one_epoch(model, optimizer, criterion, train_loader, device)\n",
-    "\n",
-    "    # Validate\n",
-    "    val_loss = validate(model, criterion, test_loader, device)\n",
-    "\n",
-    "    train_losses.append(train_loss)\n",
-    "    val_losses.append(val_loss)\n",
-    "\n",
-    "    print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')\n",
-    "\n",
-    "print('Training Complete!')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 3: Plots\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "1. Plot the training and validation loss over epochs\n",
-    "2. **Bonus:** Plot some predictions with their actual images (show predicted age vs actual age)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "plt.plot(train_losses, label='Train Loss')\n",
-    "plt.plot(val_losses, label='Validation Loss')\n",
-    "plt.title('Loss over Epochs')\n",
-    "plt.xlabel('Epoch')\n",
-    "plt.ylabel('Loss')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "model.eval()\n",
-    "images, labels = next(iter(test_loader))\n",
-    "images = images.to(device)\n",
-    "with torch.no_grad():\n",
-    "    preds = model(images.view(images.size(0), -1))\n",
-    "\n",
-    "plt.figure(figsize=(10, 5))\n",
-    "for i in range(4):\n",
-    "    plt.subplot(1, 4, i+1)\n",
-    "    img = images[i].cpu().permute(1, 2, 0).numpy()\n",
-    "    plt.imshow(img)\n",
-    "    plt.title(f\"Real: {labels[i].item():.0f}\\nPred: {preds[i].item():.0f}\")\n",
-    "    plt.axis(\"off\")\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

Solutions/.ipynb_checkpoints/Q3_Classification_Solution-checkpoint.ipynb

@@ -1,397 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Question 3: Exploring Anonymized Data - Can You Find the Golden Feature?\n",
-    "\n",
-    "\n",
-    "\n",
-    "**What is Anonymized Data?**\n",
-    "\n",
-    "\n",
-    "\n",
-    "Anonymized data is information that has been processed to remove or obscure personally identifiable details, making it impossible to trace back to specific individuals. In credit risk modeling, features are often anonymized (e.g., `P_2`, `D_39`, `B_1`) to protect customer privacy while still enabling powerful predictive analytics.\n",
-    "\n",
-    "\n",
-    "\n",
-    "**The Challenge:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "Credit default prediction is central to managing risk in consumer lending. American Express, the world's largest payment card issuer, uses machine learning to predict whether cardholders will default on their payments. This helps optimize lending decisions and creates a better customer experience.\n",
-    "\n",
-    "\n",
-    "\n",
-    "You are provided with an anonymized dataset containing behavioral and profile features. Your objective is to build a classification model that predicts credit default (0 = No Default, 1 = Default).\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Your Mission:** Can you discover the 'golden feature' - the most powerful predictor hidden in this anonymized data?\n",
-    "\n",
-    "\n",
-    "\n",
-    "Your work will be evaluated based on the completion of the following tasks:\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 1: Read Data\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "1. Read the dataset `Q3_data.csv` using `read_csv()`\n",
-    "\n",
-    "2. Inspect the first few rows using `head()`\n",
-    "\n",
-    "3. Display dataset information using `info()`\n",
-    "\n",
-    "4. Show statistical description using `describe()`\n",
-    "\n",
-    "5. Plot the target distribution (target column)\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import kagglehub\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Download latest version\n",
-    "\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q3-ka-ai-2026\")\n",
-    "\n",
-    "\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# The 'path' variable is defined in the download cell\n",
-    "df = pd.read_csv(os.path.join(path, 'Q3_data.csv'))\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.head()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.info()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df.describe()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df['Target'].value_counts().plot(kind='bar')\n",
-    "plt.title('Target Distribution (0: No Default, 1: Default)')\n",
-    "plt.xlabel('Target')\n",
-    "plt.ylabel('Count')\n",
-    "plt.show()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 2: Data Cleaning\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "Inspect and fix the following when needed:\n",
-    "\n",
-    "\n",
-    "\n",
-    "1. **Handle missing values appropriately**\n",
-    "\n",
-    "2. **Check and remove duplicates** if any exist\n",
-    "\n",
-    "3. **Encode categorical variables** if needed\n",
-    "\n",
-    "4. **Apply feature scaling** to numerical features (Use StandardScaler)\n",
-    "\n",
-    "5. **Check for target imbalance and state if it is imbalanced or not**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "print(df.isnull().sum())\n",
-    "df = df.fillna(df.median())\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "print(f'Duplicates: {df.duplicated().sum()}')\n",
-    "df = df.drop_duplicates()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "\n",
-    "categorical_cols = df.select_dtypes(include=['object']).columns\n",
-    "if len(categorical_cols) > 0:\n",
-    "    le = LabelEncoder()\n",
-    "    for col in categorical_cols:\n",
-    "        df[col] = le.fit_transform(df[col].astype(str))\n",
-    "    print(f'Encoded columns: {list(categorical_cols)}')\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.preprocessing import StandardScaler\n",
-    "\n",
-    "scaler = StandardScaler()\n",
-    "X_cols = df.drop(columns=['Target']).columns\n",
-    "df[X_cols] = scaler.fit_transform(df[X_cols])\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "df['Target'].value_counts()\n",
-    "# there is imbalance"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 3: Modeling\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "1. Split the dataset into features (X) and target (y)\n",
-    "\n",
-    "2. Use the correct split: **KFold** OR **StratifiedKFold**\n",
-    "\n",
-    "3. Train a **CatBoostClassifier** model\n",
-    "\n",
-    "4. Evaluate using the appropriate metric only (Accuracy vs. F1 Score).\n",
-    "\n",
-    "5. Print the averaged score across all folds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "X = df.drop(columns=['Target'])\n",
-    "y = df['Target']\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.model_selection import StratifiedKFold\n",
-    "from sklearn.ensemble import RandomForestClassifier\n",
-    "from catboost import CatBoostClassifier\n",
-    "from sklearn.metrics import f1_score\n",
-    "\n",
-    "skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
-    "model = CatBoostClassifier(n_estimators=100, random_state=42)\n",
-    "\n",
-    "f1 = []\n",
-    "\n",
-    "for train_idx, val_idx in skf.split(X, y):\n",
-    "    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]\n",
-    "    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n",
-    "    \n",
-    "    model.fit(X_train, y_train)\n",
-    "    preds = model.predict(X_val)\n",
-    "    f1.append(f1_score(y_val, preds))\n",
-    "\n",
-    "print(f'F1: {np.mean(f1):.4f}')\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 4: Find the Golden Feature!\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Tasks:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "1. Plot feature importance from your trained model\n",
-    "\n",
-    "2. Identify and print the name of the most important feature (the 'golden feature')\n",
-    "\n",
-    "3. Plot the distribution of predictions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "importances = model.feature_importances_\n",
-    "feat_importances = pd.Series(importances, index=X.columns).sort_values(ascending=False)\n",
-    "\n",
-    "plt.figure(figsize=(10, 6))\n",
-    "feat_importances[:10].plot(kind='barh')\n",
-    "plt.gca().invert_yaxis()\n",
-    "plt.title('Top 10 Feature Importances')\n",
-    "plt.xlabel('Importance')\n",
-    "plt.show()\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "golden_feature = feat_importances.index[0]\n",
-    "print(f'The Golden Feature is: {golden_feature}')\n",
-    "print(f'Importance: {feat_importances.iloc[0]:.4f}')\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Part 5: Bonus - Retrain with Golden Feature Only\n",
-    "\n",
-    "\n",
-    "\n",
-    "**Task:**\n",
-    "\n",
-    "\n",
-    "\n",
-    "Now that you've found the golden feature, let's see how powerful it really is!\n",
-    "\n",
-    "\n",
-    "\n",
-    "Retrain your CatBoostClassifier using **ONLY the golden feature** and compare its performance to the full model:\n",
-    "\n",
-    "\n",
-    "\n",
-    "1. Create new X with only the golden feature\n",
-    "\n",
-    "2. Run the same KFold loop with this single feature\n",
-    "\n",
-    "3. Print and compare the accuracy with the full model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "from sklearn.model_selection import StratifiedKFold\n",
-    "from sklearn.ensemble import RandomForestClassifier\n",
-    "from catboost import CatBoostClassifier\n",
-    "from sklearn.metrics import f1_score\n",
-    "\n",
-    "skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
-    "model = CatBoostClassifier(n_estimators=100, random_state=42)\n",
-    "\n",
-    "# Retrain with only the golden feature\n",
-    "X_golden = X[[golden_feature]]\n",
-    "\n",
-    "golden_accuracies = []\n",
-    "for train_idx, val_idx in skf.split(X_golden, y):\n",
-    "    X_train, X_val = X_golden.iloc[train_idx], X_golden.iloc[val_idx]\n",
-    "    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n",
-    "    \n",
-    "    model.fit(X_train, y_train)\n",
-    "    preds = model.predict(X_val)\n",
-    "    golden_accuracies.append(f1_score(y_val, preds))\n",
-    "\n",
-    "print(f'Accuracy with ONLY {golden_feature}: {np.mean(golden_accuracies):.4f}')\n",
-    "print(f'Full Model Accuracy: {np.mean(f1):.4f}')\n",
-    "print(f'Difference: {np.mean(f1) - np.mean(golden_accuracies):.4f}')\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

submissions_extracted/1001/.ipynb_checkpoints/Q1-checkpoint.ipynb

@@ -1,229 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "import kagglehub\n",
-    "import os\n",
-    "from tqdm import tqdm\n",
-    "\n",
-    "from sklearn.preprocessing import OneHotEncoder\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "\n",
-    "%matplotlib inline"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Download latest version\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q1-ka-ai-2026\")\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:\n",
-    "csv_path = os.path.join(path, 'Q1_data.csv')\n",
-    "df = pd.read_csv(csv_path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:\n",
-    "df.head()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3: Write your code here:\n",
-    "df.info()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4: Write your code here:\n",
-    "df.describe()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 5: Write your code here:\n",
-    "def check_target_distribution(df, target_column):\n",
-    "  df[target_column].hist(bins=30, edgecolor='black')\n",
-    "\n",
-    "  plt.title(f\"Target Distribution ({target_column})\")\n",
-    "  plt.xlabel(target_column)\n",
-    "  plt.ylabel(\"Delivery_Time\")\n",
-    "  plt.grid(False)\n",
-    "\n",
-    "  plt.show()\n",
-    "\n",
-    "check_target_distribution(df, \"Delivery_Time\")"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:\n",
-    "df.drop(columns=['Order_ID'])"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:\n",
-    "# Missing values\n",
-    "print(\"Missing values:\")\n",
-    "print(df.isnull().sum())"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3: Write your code here:\n",
-    "# Duplicates\n",
-    "print(\"Duplicates:\")\n",
-    "print(df.duplicated().sum())"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "#Remove duplicates\n",
-    "df.drop_duplicates(inplace=True)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4: Write your code here:\n",
-    "categorical_cols = df.select_dtypes(include=[\"object\"]).columns\n",
-    "\n",
-    "print(\"Categorical Columns:\", list(categorical_cols))"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 5: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 6: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:\n",
-    "X = df\n",
-    "y = df"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2,3,4,5: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task Bonus: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

submissions_extracted/1001/.ipynb_checkpoints/Q2-checkpoint.ipynb

@@ -1,198 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import kagglehub\n",
-    "\n",
-    "# Download latest version\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q2-ka-ai-2026\")\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import os\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from PIL import Image\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "\n",
-    "# Load Labels\n",
-    "labels_df = pd.read_csv(os.path.join(path, \"labels.csv\"))\n",
-    "img_dir = os.path.join(path, \"images\")\n",
-    "\n",
-    "images = []\n",
-    "ages = []\n",
-    "\n",
-    "# Load Images and Resize\n",
-    "print(\"Loading images...\")\n",
-    "for index, row in labels_df.iterrows():\n",
-    "    img_name = row.iloc[0]\n",
-    "    age = row.iloc[1]\n",
-    "    img_path = os.path.join(img_dir, img_name)\n",
-    "\n",
-    "    if os.path.exists(img_path):\n",
-    "        img = Image.open(img_path).convert('RGB')\n",
-    "        img_array = np.array(img) / 255.0 # Normalize pixel values to [0, 1]\n",
-    "        images.append(img_array)\n",
-    "        ages.append(age)\n",
-    "\n",
-    "X = np.array(images)\n",
-    "y = np.array(ages)\n",
-    "\n",
-    "# Transpose image dimensions to match PyTorch format (N, C, H, W)\n",
-    "X = np.transpose(X, (0, 3, 1, 2))\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\"X_train shape: {X_train.shape}\")\n",
-    "print(f\"X_test shape: {X_test.shape}\")\n",
-    "print(f\"y_train shape: {y_train.shape}\")\n",
-    "print(f\"y_test shape: {y_test.shape}\")"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# 1. Convert Numpy arrays to PyTorch Tensors\n",
-    "import torch\n",
-    "\n",
-    "# Create tensors\n",
-    "X_train = torch.tensor([1.0, 2.0, 3.0])\n",
-    "y_train = torch.randn(3)\n",
-    "print(\"x:\", x)\n",
-    "print(\"y:\", y)\n",
-    "\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# 2. Create TensorDataset objects\n",
-    "\n",
-    "\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# 3. Create DataLoaders\n",
-    "\n",
-    "\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# 4. Print shape of one batch\n",
-    "\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# 5. Display sample images\n",
-    "\n"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your model class here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your training loop here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3: Write your validation loop here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4: Define device, model, loss, optimizer:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 5: Start training for 20 epochs:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2 (Bonus): Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

submissions_extracted/1001/.ipynb_checkpoints/Q3-checkpoint.ipynb

@@ -1,160 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "import kagglehub\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Download latest version\n",
-    "\n",
-    "path = kagglehub.dataset_download(\"mohammad2012191/q3-ka-ai-2026\")\n",
-    "\n",
-    "\n",
-    "\n",
-    "print(\"Path to dataset files:\", path)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 3: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 4: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 5: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2,3,4,5: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 1: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task 2: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# Task Bonus: Write your code here:"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}