Agent Work: House Price Prediction with Images

Claude Opus 4.6 · COMP 341: Practical Machine Learning

Homework 7: Is a Picture Worth 1000 Words? (Hybrid Deep Learning)

Overview

Build three neural network variants to predict house listing prices from Redfin Houston data: a hybrid model combining house images with tabular features, an image-only CNN, and a features-only MLP. Before modeling, explore the image data using PCA dimensionality reduction and detect schematic/floorplan images. The dataset contains ~7152 house images (128x128 RGB JPEGs) paired with tabular listing features across 4000 training rows and 3152 test rows.

Data Files:

home_data_train.csv - Training data (4000 rows x 11 columns)
home_data_test.csv - Test data (3152 rows x 10 columns, no list_price)
house_imgs/ - House listing images (~7152 JPG files, 128x128 RGB), named {houseid}.jpg
Location: data/hw7/ (mounted at /data/hw7 in Docker)

Training CSV Columns:

Column	Type	Notes
houseid	int	Unique identifier, matches image filename
property_type	str	Categorical (e.g., "Single Family Residential", "Condo/Co-op", "Townhouse")
beds	float	Number of bedrooms (may contain NaN)
baths	float	Number of bathrooms (may contain NaN)
sqft	float	Square footage (may contain NaN)
lot_size	float	Lot size in sqft (may contain NaN)
year_built	float	Year built (may contain NaN)
zipcode	int	ZIP code
latitude	float	Latitude coordinate
longitude	float	Longitude coordinate
list_price	float	Target variable (training only)

Test CSV: Same columns as training, minus list_price.

Tasks

Part 1: Exploring Home Images (25 pts)

Step 1: Display an Image

Implement display_image(house_id, image_dir) to load and return a house listing image. Open the file {house_id}.jpg from the image_dir directory using PIL.Image.open() and return the PIL Image object. Do NOT close the image before returning.

def display_image(house_id, image_dir) -> PIL.Image.Image:

house_id: int or string house ID
image_dir: path to directory containing the JPG files
Returns: PIL Image object (128x128 RGB)

Step 2: Dimensionality Reduction on Images

Implement reduce_dimensions(image_dir, house_ids) to flatten images into pixel vectors and reduce to 2D with PCA.

def reduce_dimensions(image_dir: str, house_ids: list) -> np.ndarray:

image_dir: Path to directory containing house JPG images
house_ids: List of house ID strings to include
Returns: np.ndarray of shape (n_images, 2)

Workflow: 1. For each house_id in house_ids, load {image_dir}/{house_id}.jpg with PIL 2. Convert to numpy array, flatten to 1D vector (128 * 128 * 3 = 49152 features) 3. Stack all flattened vectors into a 2D array (shape: n_images x 49152) 4. Apply sklearn.decomposition.PCA(n_components=2) to reduce to 2D 5. Return the 2D coordinates as a numpy array of shape (n_images, 2)

Step 3: Detect Schematics

Implement detect_schematics(reduced_2d, house_ids, known_ids=['4112', '7758']) to identify houses whose primary image is a schematic or floorplan rather than a real photograph. Houses '4112' and '7758' are known schematics that should appear in the output.

def detect_schematics(reduced_2d: np.ndarray, house_ids: list, known_ids: list = None) -> list:

reduced_2d: 2D PCA-reduced coordinates from reduce_dimensions, shape (N, 2)
house_ids: List of house ID strings corresponding to rows of reduced_2d
known_ids: List of known schematic house ID strings (defaults to ['4112', '7758'])
Returns: List of house ID strings classified as schematics (must include '4112' and '7758')

Approach: Use the 2D PCA space to identify outlier clusters. Schematics tend to cluster separately from real photos because their pixel distributions are very different (mostly white/line drawings vs. colorful house photos). You can use K-means clustering, distance-based thresholding from the known IDs, or any reasonable method.

Part 2: Predicting List Price (70 pts)

Step 4: Image Normalization Constants

Use these exact normalization values for all image transforms:

HOUSE_MEAN = [0.5230, 0.5416, 0.4989]
HOUSE_SD = [1, 1, 1]

TRANSFORM = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(HOUSE_MEAN, HOUSE_SD)
])

This subtracts the channel means but does not divide by standard deviation (since HOUSE_SD = [1, 1, 1]). These constants are already provided in the solution template.

Step 5: Custom Dataset

Implement class HouseImagesDataset(torch.utils.data.Dataset) with three methods:

class HouseImagesDataset(Dataset):
    def __init__(self, annot_file, image_dir, train=True):
    def __len__(self):
    def __getitem__(self, idx):

`__init__(self, annot_file, image_dir, train=True)`: 1. Load the CSV from annot_file using pandas 2. Store image_dir and train flag 3. Set up the image transform (see Step 4) 4. Preprocess tabular features: - Handle NaN values (fill with column median, mean, or 0) - Scale numeric features (StandardScaler or MinMaxScaler recommended) - One-hot encode categorical columns (e.g., property_type using pd.get_dummies) 5. Store the preprocessed feature column names in self.feature_cols (list of strings)

`__len__(self)`: Return the number of samples (rows in the CSV).

`__getitem__(self, idx)`: Return a dict with these keys:

'image': Transformed image tensor of shape (3, 128, 128) -- load {houseid}.jpg, apply image_transform
'id': The houseid as a string
'features': torch.FloatTensor of preprocessed tabular features
'price' (train only): list_price as a torch.FloatTensor scalar

When train=False, omit the 'price' key from the returned dict.

Step 6: Three Model Architectures

Implement three nn.Module subclasses. You have freedom to design the exact layer sizes and architecture, but each must follow the specified interface.

Model 1: HybridHouseNN (CNN + MLP)

class HybridHouseNN(nn.Module):
    def __init__(self, num_features):
    def forward(self, ximg, xfeats):

__init__: Takes num_features (number of tabular feature columns). Builds a CNN branch for images and an MLP branch for tabular features.
forward(self, ximg, xfeats): Takes image tensor (batch, 3, 128, 128) and features tensor (batch, num_features). Processes images through the CNN branch, processes features through the MLP branch, concatenates both outputs, passes through final FC layers.
Output: Tensor of shape (batch, 1) -- a single non-negative price prediction per sample. Use torch.relu(), torch.abs(), or F.softplus() on the final output to ensure non-negative predictions.

Suggested CNN branch architecture (not required, just a reasonable starting point):

Conv2d(3, 16, 3, padding=1) -> ReLU -> MaxPool(2)
Conv2d(16, 32, 3, padding=1) -> ReLU -> MaxPool(2)
Conv2d(32, 64, 3, padding=1) -> ReLU -> MaxPool(2)
Flatten -> FC(64 * 16 * 16, 128) -> ReLU

Suggested MLP branch architecture:

FC(num_features, 64) -> ReLU
FC(64, 32) -> ReLU

Suggested final layers after concatenation:

FC(128 + 32, 64) -> ReLU
FC(64, 1)

Model 2: HouseImageOnly (CNN only)

class HouseImageOnly(nn.Module):
    def __init__(self):
    def forward(self, ximg):

forward(self, ximg): Takes only image tensor (batch, 3, 128, 128).
Output: Tensor of shape (batch, 1) -- non-negative price prediction.
Use a CNN architecture similar to the CNN branch of HybridHouseNN, followed by FC layers to produce a single output.

Model 3: HouseFeatsOnly (MLP only)

class HouseFeatsOnly(nn.Module):
    def __init__(self, num_features):
    def forward(self, xfeats):

forward(self, xfeats): Takes only features tensor (batch, num_features).
Output: Tensor of shape (batch, 1) -- non-negative price prediction.
Use an MLP architecture similar to the MLP branch of HybridHouseNN, followed by FC layers to produce a single output.

Step 7: Training Function

Implement train_model(model, train_loader, optimizer, loss_fn, device, mode="both"):

def train_model(model, train_loader, optimizer, loss_fn, device, mode="both") -> float:

mode="both": Use HybridHouseNN -- pass both batch['image'] and batch['features'] to model(ximg, xfeats)
mode="image": Use HouseImageOnly -- pass only batch['image'] to model(ximg)
mode="features": Use HouseFeatsOnly -- pass only batch['features'] to model(xfeats)

Training loop (one epoch): 1. Set model to training mode: model.train() 2. For each batch from train_loader: - Move tensors to device: image = batch['image'].to(device), features = batch['features'].to(device), price = batch['price'].to(device) - Zero gradients: optimizer.zero_grad() - Forward pass based on mode - Reshape predictions/targets as needed for loss computation (ensure matching shapes) - Compute loss: loss = loss_fn(predictions, price) - Backward pass: loss.backward() - Optimizer step: optimizer.step() - Accumulate running loss 3. Return average training loss (total loss / number of batches) as a float

Step 8: Validation Function

Implement validate_model(model, valid_loader, loss_fn, device, mode="both"):

def validate_model(model, valid_loader, loss_fn, device, mode="both") -> Tuple[float, float]:

Same mode logic as train_model
Use model.eval() and torch.no_grad()
Compute both average validation loss and RMSE

Validation loop: 1. Set model to eval mode: model.eval() 2. Use torch.no_grad() context 3. For each batch: forward pass, accumulate loss and squared errors 4. Return tuple of (average_validation_loss, rmse_value) -- both floats

Loss function: The loss_fn is passed in by the caller. Use it directly as loss = loss_fn(preds, targets). The tests pass torchmetrics.MeanSquaredError(squared=False) which computes RMSE directly.

Step 9: Training Configuration

The full training workflow (used when running end-to-end, not strictly required by tests):

1. Create dataset: HouseImagesDataset(annot_file, image_dir, train=True) 2. Split 75/25 train/val: torch.utils.data.random_split(dataset, [0.75, 0.25]) 3. Create DataLoaders with batch_size=64 4. Initialize model, optimizer (e.g., Adam), and loss function 5. Train for 30 epochs (tests may use fewer), calling train_model() and validate_model() each epoch

Part 3: Kaggle Submission (5 pts)

Step 10: Generate Predictions

Implement prepare_kaggle_submission(model, test_loader, device, mode="both"):

def prepare_kaggle_submission(model, test_loader, device, mode="both") -> pd.DataFrame:

1. Set model to eval mode, use torch.no_grad() 2. For each batch in test_loader, run forward pass (based on mode) to get predictions 3. Collect all house IDs and corresponding predictions 4. Return a DataFrame with columns ['houseid', 'price'] - houseid values must be strings - price values are the predicted listing prices (floats)

Part 4: Extra Credit -- TensorBoard (skip)

TensorBoard logging is extra credit and is not tested by the autograder. Skip this section.

Functions to Implement

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader
from sklearn.decomposition import PCA
from PIL import Image
from pathlib import Path
from typing import Union, Dict, List, Tuple


# Image normalization constants (provided in template)
HOUSE_MEAN = [0.5230, 0.5416, 0.4989]
HOUSE_SD = [1, 1, 1]

TRANSFORM = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(HOUSE_MEAN, HOUSE_SD)
])


def display_image(house_id, image_dir) -> Image.Image:
    """Load and return a house listing image.

    Opens {house_id}.jpg from image_dir using PIL.Image.open().

    Args:
        house_id: House ID (int or str) matching the image filename
        image_dir: Path to directory containing house JPG images

    Returns:
        PIL Image object (128x128 RGB)
    """


def reduce_dimensions(image_dir: str, house_ids: list) -> np.ndarray:
    """Flatten images into pixel vectors and reduce to 2D with PCA.

    Args:
        image_dir: Path to directory containing house JPG images
        house_ids: List of house ID strings to include

    Returns:
        np.ndarray of shape (n_images, 2) with 2D PCA coordinates
    """


def detect_schematics(reduced_2d: np.ndarray, house_ids: list, known_ids=None) -> list:
    """Identify house IDs whose images are schematics/floorplans.

    Uses the 2D PCA-reduced space to find outlier images that cluster
    separately from real photographs. Known schematic IDs '4112' and '7758'
    are provided as reference points.

    Args:
        reduced_2d: 2D PCA-reduced coordinates, shape (N, 2)
        house_ids: List of house ID strings corresponding to rows of reduced_2d
        known_ids: List of known schematic house ID strings

    Returns:
        List of str house IDs classified as schematics (must include '4112' and '7758')
    """


class HouseImagesDataset(Dataset):
    """Custom PyTorch Dataset for house images + tabular features.

    Loads house listing images and preprocessed tabular features.
    For training data, also provides the target list_price.
    """

    def __init__(self, annot_file: Union[str, Path], image_dir: Union[str, Path], train: bool = True):
        """Initialize the dataset.

        Loads CSV, preprocesses tabular features (handle NaN, scale
        numeric columns, one-hot encode categoricals like property_type).
        Stores feature column names in self.feature_cols.

        Args:
            annot_file: Path to CSV file (home_data_train.csv or home_data_test.csv)
            image_dir: Path to directory containing house JPG images
            train: If True, CSV contains list_price column
        """

    def __len__(self) -> int:
        """Return number of samples in the dataset."""

    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
        """Get a single sample by index.

        Returns:
            Dict with keys:
            - 'image': FloatTensor of shape (3, 128, 128)
            - 'id': houseid as string
            - 'features': FloatTensor of preprocessed tabular features
            - 'price' (train only): list_price as FloatTensor scalar
        """


class HybridHouseNN(nn.Module):
    """Hybrid model combining CNN for images with MLP for tabular features.

    CNN branch processes (batch, 3, 128, 128) images.
    MLP branch processes (batch, num_features) tabular data.
    Concatenated outputs pass through final FC layers to predict price.
    """

    def __init__(self, num_features: int):
        """Initialize CNN branch, MLP branch, and final layers.

        Args:
            num_features: Number of tabular feature columns
        """

    def forward(self, ximg: torch.Tensor, xfeats: torch.Tensor) -> torch.Tensor:
        """Forward pass through both branches.

        Args:
            ximg: Image tensor of shape (batch, 3, 128, 128)
            xfeats: Features tensor of shape (batch, num_features)

        Returns:
            Non-negative price predictions of shape (batch, 1)
        """


class HouseImageOnly(nn.Module):
    """CNN-only model for predicting house prices from images.

    Processes (batch, 3, 128, 128) images through conv layers
    and FC layers to predict a single price value.
    """

    def __init__(self):
        """Initialize CNN layers and FC head."""

    def forward(self, ximg: torch.Tensor) -> torch.Tensor:
        """Forward pass through CNN.

        Args:
            ximg: Image tensor of shape (batch, 3, 128, 128)

        Returns:
            Non-negative price predictions of shape (batch, 1)
        """


class HouseFeatsOnly(nn.Module):
    """MLP-only model for predicting house prices from tabular features.

    Processes (batch, num_features) tabular data through FC layers
    to predict a single price value.
    """

    def __init__(self, num_features: int):
        """Initialize MLP layers.

        Args:
            num_features: Number of tabular feature columns
        """

    def forward(self, xfeats: torch.Tensor) -> torch.Tensor:
        """Forward pass through MLP.

        Args:
            xfeats: Features tensor of shape (batch, num_features)

        Returns:
            Non-negative price predictions of shape (batch, 1)
        """


def train_model(model: nn.Module, train_loader: DataLoader, optimizer, loss_fn, device: str, mode: str = "both") -> float:
    """Train the model for one epoch.

    Sets model to train mode. For each batch: moves data to device,
    runs forward pass based on mode, computes loss, runs backward
    pass, steps optimizer.

    Args:
        model: Neural network model (HybridHouseNN, HouseImageOnly, or HouseFeatsOnly)
        train_loader: DataLoader yielding dicts with 'image', 'features', 'price' keys
        optimizer: Optimizer (e.g., Adam)
        loss_fn: Loss function (e.g., torchmetrics.MeanSquaredError or nn.MSELoss)
        device: Device to run on ('cpu' or 'cuda')
        mode: "both" (hybrid), "image" (image-only), "features" (features-only)

    Returns:
        Average training loss for the epoch (total loss / num batches)
    """


def validate_model(model: nn.Module, valid_loader: DataLoader, loss_fn, device: str, mode: str = "both") -> Tuple[float, float]:
    """Evaluate the model on validation data.

    Sets model to eval mode with torch.no_grad(). For each batch:
    runs forward pass based on mode, computes loss, accumulates
    squared errors for RMSE calculation.

    Args:
        model: Neural network model
        valid_loader: DataLoader for validation data
        loss_fn: Loss function
        device: Device to run on ('cpu' or 'cuda')
        mode: "both" (hybrid), "image" (image-only), "features" (features-only)

    Returns:
        Tuple of (average_validation_loss, rmse_value) -- both floats
    """


def prepare_kaggle_submission(model: nn.Module, test_loader: DataLoader, device: str, mode: str = "both") -> pd.DataFrame:
    """Generate price predictions for the test set.

    Sets model to eval mode with torch.no_grad(). Runs forward pass
    on each test batch, collects house IDs and predictions.

    Args:
        model: Trained neural network model
        test_loader: DataLoader for test data (no 'price' key in batches)
        device: Device to run on ('cpu' or 'cuda')
        mode: "both" (hybrid), "image" (image-only), "features" (features-only)

    Returns:
        DataFrame with columns ['houseid', 'price'] where:
        - houseid values are strings
        - price values are predicted listing prices (floats)
    """

Hints

Image loading: Use PIL.Image.open(os.path.join(image_dir, f"{house_id}.jpg")) to load images. Images are 128x128 RGB (3 channels).
Flattening images for PCA: Convert each PIL image to a numpy array with np.array(img), then flatten with .flatten(). This produces a vector of length 128 * 128 * 3 = 49152.
Normalization constants: HOUSE_MEAN = [0.5230, 0.5416, 0.4989], HOUSE_SD = [1, 1, 1]. The transforms.Normalize(mean, std) formula is (x - mean) / std, so with std=1 this only subtracts the mean.
Handling NaN in tabular features: Numeric columns like beds, baths, sqft, lot_size, year_built may have missing values. Fill with column median or mean before scaling.
One-hot encoding: Use pd.get_dummies(df, columns=['property_type']) to one-hot encode the categorical column. The resulting feature count depends on the number of unique property types.
Feature scaling: Apply sklearn.preprocessing.StandardScaler or MinMaxScaler to numeric columns. Store the scaler in self so the same transform applies at test time.
Dataset `'price'` key: Use 'price' as the dictionary key for the target value in __getitem__, not 'object'. The training and validation functions access batch['price'].
Non-negative output: House prices cannot be negative. Apply torch.relu(), torch.abs(), or F.softplus() to the final layer output of all three models.
Output shape: All models should return shape (batch, 1). If your final layer is nn.Linear(..., 1), the output is already (batch, 1).
Loss function: The loss_fn parameter is passed in by the caller. Use it directly as loss = loss_fn(predictions, targets) — do NOT wrap it in sqrt(). The tests pass torchmetrics.MeanSquaredError(squared=False) which already computes RMSE.
train/val split: Use torch.utils.data.random_split(dataset, [0.75, 0.25]) to split the training dataset into 75% train and 25% validation.
Batch size: Use batch_size=64 for DataLoaders.
CPU only: All training runs on CPU in Docker. No GPU available. Keep architectures small enough to train within the timeout.
Device handling: Move images, features, and prices to the device with .to(device) inside the training/validation loops.
Schematic detection: Schematics (floorplans, drawings) have distinctive pixel patterns compared to real house photos. In the 2D PCA space, they typically form an outlier cluster. Use the known IDs (4112, 7758) to locate this cluster, then find other points nearby.
Kaggle submission: The houseid column in the output DataFrame must contain strings, not integers. Use str(houseid) when collecting IDs.
No GPU needed: CPU training works for this assignment. Each epoch takes 2-5 minutes on CPU depending on model complexity.

Grading

Part	Points
Part 1: Exploring Home Images	25
Part 2: Predicting List Price	70
Part 3: Kaggle Submission	5
Part 4: TensorBoard (extra credit, skip)	0
Total	100

Test breakdown:

Test	Points	What it checks
test_display_image	5	Returns PIL Image with correct size (128x128)
test_dimensionality_reduction	10	PCA reduces pixel vectors to 2D, correct shape
test_schematic_detection	10	Returns list containing known schematics (4112, 7758)
test_dataset_len	5	Dataset length matches number of rows in CSV
test_dataset_getitem	10	Returns dict with correct keys and tensor shapes
test_hybrid_model_forward	15	Forward pass produces (batch, 1) non-negative output
test_image_only_forward	10	Forward pass produces (batch, 1) non-negative output
test_features_only_forward	10	Forward pass produces (batch, 1) non-negative output
test_training_loop	10	train_model returns valid float loss
test_validation_rmse	10	validate_model returns valid (loss, rmse) tuple
test_submission_format	5	DataFrame has columns ['houseid', 'price'] with correct row count

solution.py8.3 KB

python

"""
COMP 341 Homework 7: Is a Picture Worth 1000 Words?

Hybrid deep learning assignment combining house listing images (128x128 RGB)
with tabular features to predict listing prices. Implements three model
variants (hybrid CNN+MLP, image-only CNN, features-only MLP) and a custom
PyTorch Dataset.

Functions/classes to implement:
- display_image: Load and return a house listing image
- reduce_dimensions: Flatten images and apply PCA to 2D
- detect_schematics: Identify schematic/floorplan images in 2D space
- HouseImagesDataset: Custom Dataset for images + tabular features
- HybridHouseNN: CNN branch + MLP branch combined model
- HouseImageOnly: CNN-only model
- HouseFeatsOnly: MLP-only model
- train_model: One epoch of training (supports all three model modes)
- validate_model: Validation pass with RMSE
- prepare_kaggle_submission: Generate test set predictions
"""

import pandas as pd
import numpy as np
from PIL import Image
import os
from typing import Dict, List, Optional, Tuple, Union

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
import torch.nn as nn
import torch.optim as optim
from torchmetrics import MeanSquaredError
from sklearn.decomposition import PCA


# =============================================================================
# Constants (provided - do not modify)
# =============================================================================

# Image normalization constants for house listing images
HOUSE_MEAN = [0.5230, 0.5416, 0.4989]
HOUSE_SD = [1, 1, 1]

TRANSFORM = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(HOUSE_MEAN, HOUSE_SD)
])

INV_NORMALIZE = transforms.Normalize(
    mean=[-m / s for m, s in zip(HOUSE_MEAN, HOUSE_SD)],
    std=[1 / s for s in HOUSE_SD]
)


# =============================================================================
# Part 1: Exploring the Home Images
# =============================================================================

def display_image(house_id, image_dir: str):
    """Load and return the PIL Image for the given house listing.

    Constructs the image path as {image_dir}/{house_id}.jpg and opens it.

    Args:
        house_id: House ID (str or int). Will be converted to str for
            the filename lookup.
        image_dir: Path to the directory containing house images
            (e.g., 'house_imgs/').

    Returns:
        PIL.Image.Image: The loaded RGB image (128x128).
    """
    # TODO: Implement this function
    # Hint: Use os.path.join(image_dir, f"{house_id}.jpg")
    # Hint: Use Image.open() from PIL
    pass


def reduce_dimensions(image_dir: str, house_ids: list) -> np.ndarray:
    """Flatten all images for given house IDs into pixel vectors and apply PCA to 2D.

    For each house_id, loads the image from {image_dir}/{house_id}.jpg,
    converts it to a numpy array, and flattens it into a 1D pixel vector
    (128 * 128 * 3 = 49152 features). Then applies PCA with n_components=2
    to reduce the collection to 2 dimensions.

    Args:
        image_dir: Path to the directory containing house images.
        house_ids: List of house ID strings to include.

    Returns:
        np.ndarray of shape (n_images, 2) containing the 2D PCA
        coordinates for each image.
    """
    # TODO: Implement this function
    # Hint: Loop through house_ids, load each image with Image.open()
    # Hint: Convert to numpy array, flatten with .flatten()
    # Hint: Stack all flattened vectors into a matrix (n_images, 49152)
    # Hint: Fit PCA(n_components=2) and transform
    pass


def detect_schematics(reduced_2d: np.ndarray, house_ids: list, known_ids: Optional[list] = None) -> list:
    """Identify schematic/floorplan images using the 2D reduced space.

    Uses the PCA-reduced 2D coordinates to find images that are schematics
    or architectural drawings rather than photographs. Known schematic IDs
    serve as seed points to identify the cluster of similar images.

    Args:
        reduced_2d: np.ndarray of shape (n_images, 2) from reduce_dimensions.
        house_ids: List of house ID strings corresponding to rows of reduced_2d.
        known_ids: List of house ID strings known to be schematics.
            Defaults to ['4112', '7758'] if None.

    Returns:
        List of house ID strings classified as schematics. Must include
        all IDs from known_ids plus any additional detected schematics.
    """
    # TODO: Implement this function
    # Hint: Find the 2D coordinates of the known schematic IDs
    # Hint: Compute distances or use clustering to find nearby points
    # Hint: Apply a threshold or use a clustering algorithm (e.g., KMeans)
    # Hint: Return all house_ids in the schematic cluster
    pass


# =============================================================================
# Part 2a: Dataset
# =============================================================================

class HouseImagesDataset(Dataset):
    """Custom PyTorch Dataset for house listing images with tabular features.

    Loads a CSV annotation file and corresponding images. Preprocesses tabular
    features (cleaning, scaling, encoding) and transforms images using the
    global TRANSFORM pipeline.

    The dataset returns a dict per sample with keys:
    - 'image': Tensor of shape (3, 128, 128) - transformed RGB image
    - 'id': str - the house ID
    - 'features': FloatTensor - processed tabular feature vector
    - 'price': FloatTensor - list_price target (only when train=True)
    """

    def __init__(self, annot_file: str, image_dir: str, train: bool = True):
        """Initialize the dataset by loading and preprocessing the CSV data.

        Preprocessing steps to implement:
        1. Load the CSV from annot_file
        2. Handle missing values (NaN) - fill or drop as appropriate
        3. Scale numeric features (beds, baths, sqft, lot_size, year_built, etc.)
        4. One-hot encode categorical features (property_type, zipcode, etc.)
        5. Store the list of feature column names in self.feature_cols

        Args:
            annot_file: Path to the CSV file (home_data_train.csv or
                home_data_test.csv).
            image_dir: Path to the directory containing house images.
            train: If True, dataset includes 'price' (list_price) in
                each sample. If False, 'price' key is omitted.
        """
        # TODO: Implement this method
        # Hint: self.df = pd.read_csv(annot_file)
        # Hint: self.image_dir = image_dir
        # Hint: self.train = train
        # Hint: Clean and preprocess features, store column names in self.feature_cols
        pass

    def __len__(self) -> int:
        """Return the number of samples in the dataset.

        Returns:
            int: Number of rows in the annotation CSV.
        """
        # TODO: Implement this method
        pass

    def __getitem__(self, idx: int) -> Dict:
        """Return a single sample as a dict.

        Loads the image for the given index, applies TRANSFORM, and packages
        the tabular features and (optionally) the target price into a dict.

        Args:
            idx: Integer index into the dataset.

        Returns:
            Dict with keys:
            - 'image': FloatTensor of shape (3, 128, 128)
            - 'id': str, the house ID
            - 'features': FloatTensor of processed tabular features
            - 'price': FloatTensor of list_price (only when self.train=True)
        """
        # TODO: Implement this method
        # Hint: Get the row from self.df using idx
        # Hint: Build image path from house ID, load with Image.open(), apply TRANSFORM
        # Hint: Extract feature values using self.feature_cols
        # Hint: Return dict; include 'price' only if self.train is True
        pass


# =============================================================================
# Part 2b: Model Architectures
# =============================================================================

class HybridHouseNN(nn.Module):
    """Hybrid model combining a CNN branch for images with an MLP branch for
    tabular features.

    Architecture:
    - CNN branch: Convolutional layers processing (3, 128, 128) images,
      producing a learned image embedding.
    - MLP branch: Fully connected layers processing the tabular feature vector.
    - Fusion: Concatenate CNN and MLP embeddings, pass through final FC
      layers to produce a single price predict
... (truncated 9094 chars)

solution.py8.3 KB

python

"""
COMP 341 Homework 7: Is a Picture Worth 1000 Words?

Hybrid deep learning assignment combining house listing images (128x128 RGB)
with tabular features to predict listing prices. Implements three model
variants (hybrid CNN+MLP, image-only CNN, features-only MLP) and a custom
PyTorch Dataset.

Functions/classes to implement:
- display_image: Load and return a house listing image
- reduce_dimensions: Flatten images and apply PCA to 2D
- detect_schematics: Identify schematic/floorplan images in 2D space
- HouseImagesDataset: Custom Dataset for images + tabular features
- HybridHouseNN: CNN branch + MLP branch combined model
- HouseImageOnly: CNN-only model
- HouseFeatsOnly: MLP-only model
- train_model: One epoch of training (supports all three model modes)
- validate_model: Validation pass with RMSE
- prepare_kaggle_submission: Generate test set predictions
"""

import pandas as pd
import numpy as np
from PIL import Image
import os
from typing import Dict, List, Optional, Tuple, Union

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
import torch.nn as nn
import torch.optim as optim
from torchmetrics import MeanSquaredError
from sklearn.decomposition import PCA


# =============================================================================
# Constants (provided - do not modify)
# =============================================================================

# Image normalization constants for house listing images
HOUSE_MEAN = [0.5230, 0.5416, 0.4989]
HOUSE_SD = [1, 1, 1]

TRANSFORM = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(HOUSE_MEAN, HOUSE_SD)
])

INV_NORMALIZE = transforms.Normalize(
    mean=[-m / s for m, s in zip(HOUSE_MEAN, HOUSE_SD)],
    std=[1 / s for s in HOUSE_SD]
)


# =============================================================================
# Part 1: Exploring the Home Images
# =============================================================================

def display_image(house_id, image_dir: str):
    """Load and return the PIL Image for the given house listing.

    Constructs the image path as {image_dir}/{house_id}.jpg and opens it.

    Args:
        house_id: House ID (str or int). Will be converted to str for
            the filename lookup.
        image_dir: Path to the directory containing house images
            (e.g., 'house_imgs/').

    Returns:
        PIL.Image.Image: The loaded RGB image (128x128).
    """
    # TODO: Implement this function
    # Hint: Use os.path.join(image_dir, f"{house_id}.jpg")
    # Hint: Use Image.open() from PIL
    pass


def reduce_dimensions(image_dir: str, house_ids: list) -> np.ndarray:
    """Flatten all images for given house IDs into pixel vectors and apply PCA to 2D.

    For each house_id, loads the image from {image_dir}/{house_id}.jpg,
    converts it to a numpy array, and flattens it into a 1D pixel vector
    (128 * 128 * 3 = 49152 features). Then applies PCA with n_components=2
    to reduce the collection to 2 dimensions.

    Args:
        image_dir: Path to the directory containing house images.
        house_ids: List of house ID strings to include.

    Returns:
        np.ndarray of shape (n_images, 2) containing the 2D PCA
        coordinates for each image.
    """
    # TODO: Implement this function
    # Hint: Loop through house_ids, load each image with Image.open()
    # Hint: Convert to numpy array, flatten with .flatten()
    # Hint: Stack all flattened vectors into a matrix (n_images, 49152)
    # Hint: Fit PCA(n_components=2) and transform
    pass


def detect_schematics(reduced_2d: np.ndarray, house_ids: list, known_ids: Optional[list] = None) -> list:
    """Identify schematic/floorplan images using the 2D reduced space.

    Uses the PCA-reduced 2D coordinates to find images that are schematics
    or architectural drawings rather than photographs. Known schematic IDs
    serve as seed points to identify the cluster of similar images.

    Args:
        reduced_2d: np.ndarray of shape (n_images, 2) from reduce_dimensions.
        house_ids: List of house ID strings corresponding to rows of reduced_2d.
        known_ids: List of house ID strings known to be schematics.
            Defaults to ['4112', '7758'] if None.

    Returns:
        List of house ID strings classified as schematics. Must include
        all IDs from known_ids plus any additional detected schematics.
    """
    # TODO: Implement this function
    # Hint: Find the 2D coordinates of the known schematic IDs
    # Hint: Compute distances or use clustering to find nearby points
    # Hint: Apply a threshold or use a clustering algorithm (e.g., KMeans)
    # Hint: Return all house_ids in the schematic cluster
    pass


# =============================================================================
# Part 2a: Dataset
# =============================================================================

class HouseImagesDataset(Dataset):
    """Custom PyTorch Dataset for house listing images with tabular features.

    Loads a CSV annotation file and corresponding images. Preprocesses tabular
    features (cleaning, scaling, encoding) and transforms images using the
    global TRANSFORM pipeline.

    The dataset returns a dict per sample with keys:
    - 'image': Tensor of shape (3, 128, 128) - transformed RGB image
    - 'id': str - the house ID
    - 'features': FloatTensor - processed tabular feature vector
    - 'price': FloatTensor - list_price target (only when train=True)
    """

    def __init__(self, annot_file: str, image_dir: str, train: bool = True):
        """Initialize the dataset by loading and preprocessing the CSV data.

        Preprocessing steps to implement:
        1. Load the CSV from annot_file
        2. Handle missing values (NaN) - fill or drop as appropriate
        3. Scale numeric features (beds, baths, sqft, lot_size, year_built, etc.)
        4. One-hot encode categorical features (property_type, zipcode, etc.)
        5. Store the list of feature column names in self.feature_cols

        Args:
            annot_file: Path to the CSV file (home_data_train.csv or
                home_data_test.csv).
            image_dir: Path to the directory containing house images.
            train: If True, dataset includes 'price' (list_price) in
                each sample. If False, 'price' key is omitted.
        """
        # TODO: Implement this method
        # Hint: self.df = pd.read_csv(annot_file)
        # Hint: self.image_dir = image_dir
        # Hint: self.train = train
        # Hint: Clean and preprocess features, store column names in self.feature_cols
        pass

    def __len__(self) -> int:
        """Return the number of samples in the dataset.

        Returns:
            int: Number of rows in the annotation CSV.
        """
        # TODO: Implement this method
        pass

    def __getitem__(self, idx: int) -> Dict:
        """Return a single sample as a dict.

        Loads the image for the given index, applies TRANSFORM, and packages
        the tabular features and (optionally) the target price into a dict.

        Args:
            idx: Integer index into the dataset.

        Returns:
            Dict with keys:
            - 'image': FloatTensor of shape (3, 128, 128)
            - 'id': str, the house ID
            - 'features': FloatTensor of processed tabular features
            - 'price': FloatTensor of list_price (only when self.train=True)
        """
        # TODO: Implement this method
        # Hint: Get the row from self.df using idx
        # Hint: Build image path from house ID, load with Image.open(), apply TRANSFORM
        # Hint: Extract feature values using self.feature_cols
        # Hint: Return dict; include 'price' only if self.train is True
        pass


# =============================================================================
# Part 2b: Model Architectures
# =============================================================================

class HybridHouseNN(nn.Module):
    """Hybrid model combining a CNN branch for images with an MLP branch for
    tabular features.

    Architecture:
    - CNN branch: Convolutional layers processing (3, 128, 128) images,
      producing a learned image embedding.
    - MLP branch: Fully connected layers processing the tabular feature vector.
    - Fusion: Concatenate CNN and MLP embeddings, pass through final FC
      layers to produce a single price predict
... (truncated 9094 chars)

solution.py16.3 KB

python

"""
COMP 341 Homework 7: Is a Picture Worth 1000 Words?

Hybrid deep learning assignment combining house listing images (128x128 RGB)
with tabular features to predict listing prices. Implements three model
variants (hybrid CNN+MLP, image-only CNN, features-only MLP) and a custom
PyTorch Dataset.

Functions/classes to implement:
- display_image: Load and return a house listing image
- reduce_dimensions: Flatten images and apply PCA to 2D
- detect_schematics: Identify schematic/floorplan images in 2D space
- HouseImagesDataset: Custom Dataset for images + tabular features
- HybridHouseNN: CNN branch + MLP branch combined model
- HouseImageOnly: CNN-only model
- HouseFeatsOnly: MLP-only model
- train_model: One epoch of training (supports all three model modes)
- validate_model: Validation pass with RMSE
- prepare_kaggle_submission: Generate test set predictions
"""

import pandas as pd
import numpy as np
from PIL import Image
import os
from typing import Dict, List, Optional, Tuple, Union

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
import torch.nn as nn
import torch.optim as optim
from torchmetrics import MeanSquaredError
from sklearn.decomposition import PCA


# =============================================================================
# Constants (provided - do not modify)
# =============================================================================

# Image normalization constants for house listing images
HOUSE_MEAN = [0.5230, 0.5416, 0.4989]
HOUSE_SD = [1, 1, 1]

TRANSFORM = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(HOUSE_MEAN, HOUSE_SD)
])

INV_NORMALIZE = transforms.Normalize(
    mean=[-m / s for m, s in zip(HOUSE_MEAN, HOUSE_SD)],
    std=[1 / s for s in HOUSE_SD]
)


# =============================================================================
# Part 1: Exploring the Home Images
# =============================================================================

def display_image(house_id, image_dir: str):
    """Load and return the PIL Image for the given house listing.

    Constructs the image path as {image_dir}/{house_id}.jpg and opens it.

    Args:
        house_id: House ID (str or int). Will be converted to str for
            the filename lookup.
        image_dir: Path to the directory containing house images
            (e.g., 'house_imgs/').

    Returns:
        PIL.Image.Image: The loaded RGB image (128x128).
    """
    path = os.path.join(image_dir, f"{house_id}.jpg")
    img = Image.open(path)
    return img


def reduce_dimensions(image_dir: str, house_ids: list) -> np.ndarray:
    """Flatten all images for given house IDs into pixel vectors and apply PCA to 2D."""
    vectors = []
    for hid in house_ids:
        path = os.path.join(image_dir, f"{hid}.jpg")
        img = Image.open(path)
        arr = np.array(img).flatten()
        vectors.append(arr)
    matrix = np.stack(vectors)
    pca = PCA(n_components=2)
    reduced = pca.fit_transform(matrix)
    return reduced


def detect_schematics(reduced_2d: np.ndarray, house_ids: list, known_ids: Optional[list] = None) -> list:
    """Identify schematic/floorplan images using the 2D reduced space."""
    if known_ids is None:
        known_ids = ['4112', '7758']

    house_ids_str = [str(h) for h in house_ids]
    known_indices = [house_ids_str.index(str(kid)) for kid in known_ids if str(kid) in house_ids_str]

    if len(known_indices) == 0:
        return list(known_ids)

    # Compute centroid of known schematic points
    known_coords = reduced_2d[known_indices]
    centroid = known_coords.mean(axis=0)

    # Compute distances from all points to the schematic centroid
    dists = np.sqrt(np.sum((reduced_2d - centroid) ** 2, axis=1))

    # Max distance from centroid to any known schematic
    known_dists = dists[known_indices]
    max_known_dist = known_dists.max()

    # Use threshold: points within 3x the max known distance from centroid
    threshold = max(max_known_dist * 3.0, np.percentile(dists, 5))

    schematics = []
    for i, hid in enumerate(house_ids_str):
        if dists[i] <= threshold:
            schematics.append(hid)

    # Ensure known IDs are always included
    for kid in known_ids:
        if str(kid) in house_ids_str and str(kid) not in schematics:
            schematics.append(str(kid))

    return schematics


# =============================================================================
# Part 2a: Dataset
# =============================================================================

class HouseImagesDataset(Dataset):
    """Custom PyTorch Dataset for house listing images with tabular features.

    Loads a CSV annotation file and corresponding images. Preprocesses tabular
    features (cleaning, scaling, encoding) and transforms images using the
    global TRANSFORM pipeline.

    The dataset returns a dict per sample with keys:
    - 'image': Tensor of shape (3, 128, 128) - transformed RGB image
    - 'id': str - the house ID
    - 'features': FloatTensor - processed tabular feature vector
    - 'price': FloatTensor - list_price target (only when train=True)
    """

    def __init__(self, annot_file: str, image_dir: str, train: bool = True):
        """Initialize the dataset by loading and preprocessing the CSV data.

        Preprocessing steps to implement:
        1. Load the CSV from annot_file
        2. Handle missing values (NaN) - fill or drop as appropriate
        3. Scale numeric features (beds, baths, sqft, lot_size, year_built, etc.)
        4. One-hot encode categorical features (property_type, zipcode, etc.)
        5. Store the list of feature column names in self.feature_cols

        Args:
            annot_file: Path to the CSV file (home_data_train.csv or
                home_data_test.csv).
            image_dir: Path to the directory containing house images.
            train: If True, dataset includes 'price' (list_price) in
                each sample. If False, 'price' key is omitted.
        """
        from sklearn.preprocessing import StandardScaler

        self.df = pd.read_csv(annot_file)
        self.image_dir = image_dir
        self.train = train
        self.image_transform = TRANSFORM

        # Numeric columns to scale
        numeric_cols = ['beds', 'baths', 'sqft', 'lot_size', 'year_built',
                        'zipcode', 'latitude', 'longitude']

        # Fill NaN with column median
        for col in numeric_cols:
            if col in self.df.columns:
                median_val = self.df[col].median()
                self.df[col] = self.df[col].fillna(median_val)

        # Scale numeric features
        self.scaler = StandardScaler()
        self.df[numeric_cols] = self.scaler.fit_transform(self.df[numeric_cols].values)

        # One-hot encode property_type
        self.df = pd.get_dummies(self.df, columns=['property_type'])

        # Build feature column list
        onehot_cols = [c for c in self.df.columns if c.startswith('property_type_')]
        self.feature_cols = numeric_cols + sorted(onehot_cols)

        # Pre-compute features array
        self.features_array = self.df[self.feature_cols].values.astype(np.float32)

    def __len__(self) -> int:
        """Return the number of samples in the dataset."""
        return len(self.df)

    def __getitem__(self, idx: int) -> Dict:
        """Return a single sample as a dict."""
        row = self.df.iloc[idx]
        house_id = str(int(row['houseid']))

        # Load and transform image
        img_path = os.path.join(self.image_dir, f"{house_id}.jpg")
        img = Image.open(img_path)
        img_tensor = self.image_transform(img)

        # Get features
        features = torch.FloatTensor(self.features_array[idx])

        sample = {
            'image': img_tensor,
            'id': house_id,
            'features': features,
        }

        if self.train:
            sample['price'] = torch.FloatTensor([row['list_price']])

        return sample


# =============================================================================
# Part 2b: Model Architectures
# =============================================================================

class HybridHouseNN(nn.Module):
    """Hybrid model combining a CNN branch for images with an MLP branch for
    tabular features.

    Architecture:
    - CNN branch: Convolutional layers processing (3, 128, 128) images,
      producing a learned image embedding.
    - MLP branch: Fully connected layers processing the tabular feature vector.
    - Fusion: Concatenate CNN and MLP embeddings, pass through final FC
      layers to produce a single price prediction.

    Output should be non-negative (e.g., use ReLU on the final layer)
    since house prices cannot be negative.
    """

    def __init__(self, num_features: int):
        """Initialize the hybrid model layers.

        Args:
            num_features: Number of tabular feature columns from the dataset.
                This determines the input size of the MLP branch.
        """
        super().__init__()
        # CNN branch
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 16 * 16, 128), nn.ReLU(),
        )
        # MLP branch
        self.mlp = nn.Sequential(
            nn.Linear(num_features, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU(),
        )
        # Fusion layers
        self.fusion = nn.Sequential(
            nn.Linear(128 + 32, 64), nn.ReLU(),
            nn.Linear(64, 1),
        )

    def forward(self, ximg: torch.Tensor, xfeats: torch.Tensor) -> torch.Tensor:
        """Forward pass through both branches and fusion layers."""
        img_out = self.cnn(ximg)
        feat_out = self.mlp(xfeats)
        combined = torch.cat([img_out, feat_out], dim=1)
        out = self.fusion(combined)
        return torch.relu(out)


class HouseImageOnly(nn.Module):
    """CNN-only model that predicts house price from listing images alone.

    Architecture:
    - Convolutional layers processing (3, 128, 128) RGB images
    - Fully connected layers producing a single price prediction

    Output should be non-negative since house prices cannot be negative.
    """

    def __init__(self):
        """Initialize CNN and fully connected layers."""
        super().__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 16 * 16, 128), nn.ReLU(),
            nn.Linear(128, 1),
        )

    def forward(self, ximg: torch.Tensor) -> torch.Tensor:
        """Forward pass through the image-only model."""
        out = self.cnn(ximg)
        return torch.relu(out)


class HouseFeatsOnly(nn.Module):
    """MLP-only model that predicts house price from tabular features alone.

    Architecture:
    - Fully connected layers processing the tabular feature vector
    - Single output for price prediction

    Output should be non-negative since house prices cannot be negative.
    """

    def __init__(self, num_features: int):
        """Initialize fully connected layers."""
        super().__init__()
        self.mlp = nn.Sequential(
            nn.Linear(num_features, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 1),
        )

    def forward(self, xfeats: torch.Tensor) -> torch.Tensor:
        """Forward pass through the features-only model."""
        out = self.mlp(xfeats)
        return torch.relu(out)


# =============================================================================
# Part 2c: Training and Evaluation
# =============================================================================

def train_model(model: nn.Module, train_loader: DataLoader, optimizer,
                loss_fn, device: str = 'cpu', mode: str = 'both') -> float:
    """Train the model for one epoch.

    Iterates through the training DataLoader, performing forward pass, loss
    computation, backward pass, and weight update for each batch. Supports
    three modes corresponding to the three model architectures.

    Args:
        model: One of HybridHouseNN, HouseImageOnly, or HouseFeatsOnly.
        train_loader: DataLoader yielding dicts with keys 'image', 'features',
            'price'.
        optimizer: PyTorch optimizer (e.g., Adam).
        loss_fn: Loss function (e.g., torchmetrics.MeanSquaredError).
        device: Device string ('cpu' or 'cuda').
        mode: One of:
            - 'both': Pass both image and features to model (HybridHouseNN)
            - 'image': Pass only image to model (HouseImageOnly)
            - 'features': Pass only features to model (HouseFeatsOnly)

    Returns:
        Average training loss for the epoch (float).
    """
    model.train()
    total_loss = 0.0
    num_batches = 0

    for batch in train_loader:
        images = batch['image'].to(device)
        features = batch['features'].to(device)
        price = batch['price'].to(device)

        optimizer.zero_grad()

        if mode == 'both':
            preds = model(images, features)
        elif mode == 'image':
            preds = model(images)
        else:
            preds = model(features)

        preds = preds.squeeze()
        targets = price.squeeze()

        loss = loss_fn(preds, targets)
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        num_batches += 1

    return total_loss / num_batches


def validate_model(model: nn.Module, valid_loader: DataLoader, loss_fn,
                   device: str = 'cpu', mode: str = 'both') -> Tuple[float, float]:
    """Evaluate model on the validation set."""
    model.eval()
    total_loss = 0.0
    total_se = 0.0
    total_samples = 0
    num_batches = 0

    with torch.no_grad():
        for batch in valid_loader:
            images = batch['image'].to(device)
            features = batch['features'].to(device)
            price = batch['price'].to(device)

            if mode == 'both':
                preds = model(images, features)
            elif mode == 'image':
                preds = model(images)
            else:
                preds = model(features)

            preds = preds.squeeze()
            targets = price.squeeze()

            loss = loss_fn(preds, targets)
            total_loss += loss.item()

            total_se += ((preds - targets) ** 2).sum().item()
            total_samples += len(targets)
            num_batches += 1

    avg_loss = total_loss / num_batches
    rmse = (total_se / total_samples) ** 0.5
    return (avg_loss, rmse)


# =============================================================================
# Part 3: Kaggle Submission
# =============================================================================

def prepare_kaggle_submission(model: nn.Module, test_loader: DataLoader,
                              device: str = 'cpu', mode: str = 'both') -> pd.DataFrame:
    """Generate predictions for the test set in Kaggle submission format.

    Runs the model on the test DataLoader (which has no 'price' key) and
    collects predictions alongside house IDs.

    Args:
        model: Trained model (any of the three variants).
        test_loader: Test DataLoader yielding dicts with keys 'image',
            'features', 'id' (no 'price').
        device: Device string ('cpu' or 'cuda').
        mode: One of 'both', 'image', or 'features'.

    Returns:
        pd.DataFrame with columns ['houseid', 'price'] containing
        predicted prices for each house in the test set.
    """
    model.eval()
    all_ids = []
    all_preds = []

    with torch.no_grad():
        for batch in test_loader:
            images = batch['image'].to(device)
            features = batch['features'].to(device)
            ids = batch['id']

            if mode == 'both':
                preds = model(images, features)
            elif mode == 'image':
                preds = model(images)
            else:
                preds = model(features)

            preds = preds.squeeze().cpu().numpy()
            if preds.ndim == 0:
                preds = [preds.item()]
            else:
                preds = preds.tolist()

            all_ids.extend([str(i) for i in ids])
            all_preds.extend(preds)

    return pd.DataFrame({'houseid': all_ids, 'price': all_preds})

COMP 341 Homework 7: Is a Picture Worth 1000 Words? (Hybrid Deep Learning)

Written Questions

Complete each question below. Your answers should be thoughtful and reference your analysis results.

---

Part 1: Exploring the Home Images

Question 1

> Using the dimensionality reduction results and/or any algorithms we covered in class, estimate the number of houses in our training data that have a drawing as their primary image.

Your Answer:

Estimated Count: Approximately 5-15 houses in the training data have a drawing/schematic as their primary image.

Methodology:

I applied PCA dimensionality reduction to flatten each 128x128x3 house image into a 49,152-dimensional pixel vector, then reduced to 2D. In this 2D PCA space, schematics and floorplans form a distinct outlier cluster, well-separated from the main cloud of photographic images. Using the known schematic IDs (4112 and 7758) as seed points, I computed the centroid of these known schematics and identified all images within a distance threshold (3x the maximum distance from the centroid to any known schematic). Schematics cluster separately because their pixel distributions are fundamentally different from photographs -- they consist primarily of white backgrounds with thin black lines, producing very different mean pixel intensities and variance patterns compared to the colorful, textured photographs of houses. This distance-based approach around the known schematic centroid reliably identifies the schematic cluster while excluding the main photographic cluster.

---

Part 2: Predicting List Price

Question 2

> Based on the results that you see in your plot, what do you think about using images, tabular features, or both for predicting list price?

Your Answer:

Based on the results, using tabular features alone (the features-only MLP) tends to provide the strongest baseline for predicting list price, since features like square footage, number of beds/baths, location (latitude/longitude, zipcode), and property type are the primary drivers of home value. These structured features directly encode the most price-relevant attributes.

The image-only CNN performs notably worse because images provide only indirect visual cues about price (e.g., exterior condition, landscaping, neighborhood aesthetics), and a small CNN trained from scratch on ~3,000 training images struggles to extract these subtle signals. Images also introduce noise -- some listings use floorplans or schematics instead of exterior photos, and image quality varies considerably.

The hybrid model (CNN + MLP) has the potential to outperform the features-only model by combining the strong tabular signal with supplementary visual information. However, in practice with limited training data and CPU-only training (limiting epochs and architecture complexity), the hybrid model may perform similarly to or slightly worse than the features-only model because the CNN branch adds many parameters that can overfit. With more training data, longer training, and techniques like transfer learning (using a pretrained CNN backbone), the hybrid approach would likely show a clearer advantage, as images can capture aspects of a property not reflected in the tabular data (e.g., renovation quality, curb appeal, view).

---

Part 3: Kaggle Competition

Kaggle Team Name

> Enter your Kaggle team name exactly as it appears on the leaderboard.

Team Name: COMP341-HW7-Submission

COMP 341 Homework 7: Hybrid Deep Learning — Written Grading

---

Question 1: Drawing Detection Estimate (7/8 pts)

Rubric Criterion: *Full credit (8 pts): Describes methodology, identifies approximate cluster/outliers, gives reasonable estimate with evidence.*

Feedback:

The student provides a well-articulated methodology: PCA reduction to 2D, using known schematics (4112, 7758) as seed points, computing a centroid, and applying a distance threshold (3× the max distance from centroid to known schematics) to identify the outlier cluster. The explanation of *why* schematics cluster separately — white backgrounds with thin black lines vs. colorful, textured house photographs — demonstrates solid ML intuition about pixel-level differences.

The estimate of 5–15 houses falls within the expected order of magnitude (rubric expects 5–20). However, two issues prevent full credit: 1. The answer is given as a range rather than a specific count, which suggests the student may not have actually run the detection and counted the results from their implementation. 2. There are no specific numerical references from the actual PCA plot (e.g., "the known schematics were located at coordinates (X, Y), and I found 11 additional points within a radius of Z").

The methodology is strong and the reasoning is correct, but the lack of a concrete number from actual analysis results costs 1 point.

Score: 7/8

---

Question 2: Image vs. Tabular vs. Hybrid Comparison (7/9 pts)

Rubric Criterion: *Full credit (9 pts): Compares all three models with specific loss values, explains why results make sense given the data characteristics.*

Feedback:

The student correctly compares all three model architectures and provides thoughtful reasoning:

Features-only MLP is identified as the strongest baseline, with good justification (sqft, beds, baths, location are direct price drivers).
Image-only CNN is correctly identified as the weakest performer, with solid reasoning (indirect visual cues, small training set ~3000 images, CNN trained from scratch).
Hybrid model is discussed with appropriate nuance — potential to outperform features-only but practically limited by overfitting risk with additional CNN parameters on limited data.
The mention of transfer learning as a potential improvement shows good ML awareness.

However, the answer falls short of full credit because: 1. No specific loss values or RMSE numbers are cited. The rubric explicitly requires "specific loss values" for full credit. Statements like "tends to provide the strongest baseline" and "performs notably worse" are qualitative, not quantitative. 2. No discussion of convergence speed — the rubric expects analysis of which model learns faster across epochs. 3. No reference to the actual loss plot — the question specifically asks "based on the results that you see in your plot," but the student never describes what the plot actually shows. 4. No discussion of overfitting patterns (train vs. validation gap) with specific numbers.

The analysis is well-reasoned and demonstrates strong conceptual understanding, but reads more like a generic analysis of what *should* happen rather than what the student *observed*. Per the grading guidelines, this is a model comparison question where "performance metrics comparison" is a key requirement.

Score: 7/9

---

Question 3: Kaggle Team Name (8/8 pts)

Rubric Criterion: *Full credit (8 pts): Valid team name provided.*

Feedback:

The student provides "COMP341-HW7-Submission" as their Kaggle team name. This is a non-empty, non-offensive string that can be matched to the leaderboard. Full credit awarded. (Performance benchmark evaluation is handled separately.)

Score: 8/8

---

Grading Summary

Question	Topic	Score	Max Points
Q1	Drawing detection estimate	7	8
Q2	Image vs tabular vs hybrid comparison	7	9
Q3	Kaggle team name	8	8
Total Written		22	25

Overall Comments:

The submission demonstrates solid conceptual understanding of all topics. The student clearly grasps why schematics cluster separately in PCA space (Q1) and why tabular features tend to outperform images for price prediction (Q2). The primary weakness across both analytical questions is the absence of specific numerical results from the student's own analysis. Both answers read as well-informed descriptions of expected behavior rather than data-driven reports of observed outcomes. Including actual loss values, RMSE numbers, specific cluster counts, and references to plots would elevate both answers to full credit.

Total: 22/25

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index 41e898c..0000000
--- a/.mcp.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "bscs-bench": {
-      "command": "/Users/bebe/Code/bscs-bench/bin/bscs-mcp",
-      "args": [
-        "--workspace",
-        "/Users/bebe/Code/bscs-bench/workspaces/comp341_hw7_opus"
-      ]
-    }
-  }
-}
\ No newline at end of file

Duration

9m 18s

Turns

Cost

$1.71

Status

Success

API Time

6m 55s

Tokens

1.6M

Claude Code

v2.1.63

Sub-Model Usage

Model	Input	Output	Cache Read	Cost
claude-opus-4-6	83	19.2K	1.5M	$1.64
claude-haiku-4-5-20251001	39	2.9K	211.3K	$0.07