Exp 4 — Autoencoder for dimensionality reduction

Record-ready template Fill placeholders with your dataset, code, outputs, plots, and viva.
AIML355 • Fundamentals of Deep Learning Lab

EXP04 — Autoencoder for Dimensionality Reduction

Record-ready template Replace placeholders with your final work (code + outputs + screenshots).
Submission checklist
Aim ✓ • Environment ✓ • Dataset ✓ • Procedure ✓ • Code ✓ • Output ✓ • Discussion ✓ • Viva ✓

1) Aim

To implement an Autoencoder for dimensionality reduction in Python.

Learning outcomes
  • Explain encoder/decoder and latent space concept.
  • Train an autoencoder on tabular or image data and extract embeddings.
  • Visualize reduced features (e.g., 2D projection) and compare with PCA.

2) Requirements / Environment

Software
  • Python 3.10+ (recommended)
  • TensorFlow/Keras (or PyTorch where applicable)
  • NumPy, Pandas, Matplotlib
  • Jupyter/Colab optional
Hardware
  • CPU is OK for small runs; GPU optional
  • RAM: 4–8 GB+ recommended
Reproducibility
Record library versions and random seed in your final report.

3) Dataset

  • Source: Use a relevant dataset and cite the source in your report.
  • Features/Labels: [Describe X and y; mention classes if classification]
  • Split: [Train/Validation/Test or K-fold]
  • Preprocessing: [Scaling/Normalization, resizing, tokenization, etc.]

4) Procedure / Steps

  1. Load dataset and perform preprocessing.
  2. Define model architecture and justify key choices.
  3. Compile model (loss + optimizer + metrics).
  4. Train with validation and log curves.
  5. Evaluate on test set and compute required metrics.
  6. Summarize observations and limitations.
Model hint
Encoder: Dense layers to latent dim; Decoder: Dense layers back to input dimension.

5) Code (Skeleton)

Paste your complete runnable code below (or attach notebook link in the final submission).

import tensorflow as tf
from tensorflow import keras

# TODO: X = input features
latent_dim = 16
encoder = keras.Sequential([
  keras.layers.Input(shape=(INPUT_DIM,)),
  keras.layers.Dense(64, activation='relu'),
  keras.layers.Dense(latent_dim, name='latent')
])

decoder = keras.Sequential([
  keras.layers.Input(shape=(latent_dim,)),
  keras.layers.Dense(64, activation='relu'),
  keras.layers.Dense(INPUT_DIM)  # reconstruction
])

inp = keras.Input(shape=(INPUT_DIM,))
z = encoder(inp)
out = decoder(z)
ae = keras.Model(inp, out)
ae.compile(optimizer='adam', loss='mse')

6) Results / Output

  • Metrics: [Write your final values: accuracy/F1 or MAE/MSE]
  • Plots: [Attach loss/metric curves; prediction vs actual plots if forecasting]
  • Screenshots: [Paste screenshots of outputs, confusion matrix, sample predictions]

7) Observations / Discussion

  • [Observation 1: what changed when you tuned epochs/batch size?]
  • [Observation 2: evidence of overfitting/underfitting?]
  • [Observation 3: what improved performance (augmentation, regularization, fine-tuning)?]

8) Conclusion

Write 3–6 lines summarizing what you implemented, key result, and what you learned.

9) Viva Questions

  1. What is a latent space?
  2. How is autoencoder different from PCA?
  3. What is the difference between training and validation data?
  4. Explain overfitting and two ways to reduce it.
  5. Why do we normalize/scale inputs?
  6. What does batch size and epoch mean?
  7. How do you choose a loss function for a task?

10) Post-lab Assignment

  • Change latent dimension and compare reconstruction error.
  • Visualize embeddings using t-SNE or PCA on latent vectors.
Tip: press Esc to close.